@defold-typescript/types 0.52.0 → 0.54.0

package/fixtures/defold-1.12.4/render_doc.json

@@ -0,0 +1,1167 @@
+{
+  "elements": [
+    {
+      "type": "TYPEDEF",
+      "name": "constant_buffer",
+      "brief": "Constant buffer",
+      "description": "Constant buffer",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "value",
+          "doc": "",
+          "types": ["userdata"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "TYPEDEF",
+      "name": "render_target",
+      "brief": "Render target",
+      "description": "Render target",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "value",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "TYPEDEF",
+      "name": "texture",
+      "brief": "Texture handle",
+      "description": "Texture handle",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "value",
+          "doc": "",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.constant_buffer",
+      "brief": "create a new constant buffer.",
+      "description": "Constant buffers are used to set shader program variables and are optionally passed to the <code>render.draw()</code> function.\nThe buffer's constant elements can be indexed like an ordinary Lua table, but you can't iterate over them with pairs() or ipairs().",
+      "returnvalues": [
+        {
+          "name": "buffer",
+          "doc": "new constant buffer",
+          "types": ["constant_buffer"]
+        }
+      ],
+      "parameters": [],
+      "examples": "Set a \"tint\" constant in a constant buffer in the render script:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">constant_buffer</span><span class=\"p\">()</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">tint</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\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n</code></pre></div>\n\nThen use the constant buffer when drawing a predicate:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">,</span> <span class=\"p\">{</span><span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">constants</span><span class=\"p\">})</span>\n</code></pre></div>\n\nThe constant buffer also supports array values by specifying constants in a table:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">constant_buffer</span><span class=\"p\">()</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span>    <span class=\"o\">=</span> <span class=\"p\">{}</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span><span class=\"p\">[</span><span class=\"mi\">1</span><span class=\"p\">]</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\">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=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span><span class=\"p\">[</span><span class=\"mi\">2</span><span class=\"p\">]</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=\"mi\">1</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=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span><span class=\"p\">[</span><span class=\"mi\">3</span><span class=\"p\">]</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=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n</code></pre></div>\n\nYou can also create the table by passing the vectors directly when creating the table:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">constant_buffer</span><span class=\"p\">()</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span>    <span class=\"o\">=</span> <span class=\"p\">{</span>\n     <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\">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=\"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=\"mi\">1</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=\"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=\"mi\">0</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"p\">}</span>\n\n<span class=\"c1\">-- Add more constant to the array</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">light_colors</span><span class=\"p\">[</span><span class=\"mi\">4</span><span class=\"p\">]</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\">1</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": "render.enable_state",
+      "brief": "enables a render state",
+      "description": "Enables a particular render state. The state will be enabled until disabled.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "state",
+          "doc": "state to enable\n<ul>\n<li><code>graphics.STATE_DEPTH_TEST</code></li>\n<li><code>graphics.STATE_STENCIL_TEST</code></li>\n<li><code>graphics.STATE_BLEND</code></li>\n<li><code>graphics.STATE_ALPHA_TEST</code> (<span class=\"icon-ios\"></span><span class=\"icon-android\"></span> not available on iOS and Android)</li>\n<li><code>graphics.STATE_CULL_FACE</code></li>\n<li><code>graphics.STATE_POLYGON_OFFSET_FILL</code></li>\n</ul>",
+          "types": ["constant"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Enable stencil test when drawing the gui predicate, then disable it:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_STENCIL_TEST</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">gui_pred</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">disable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_STENCIL_TEST</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.disable_state",
+      "brief": "disables a render state",
+      "description": "Disables a render state.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "state",
+          "doc": "state to disable\n<ul>\n<li><code>graphics.STATE_DEPTH_TEST</code></li>\n<li><code>graphics.STATE_STENCIL_TEST</code></li>\n<li><code>graphics.STATE_BLEND</code></li>\n<li><code>graphics.STATE_ALPHA_TEST</code> (<span class=\"icon-ios\"></span><span class=\"icon-android\"></span> not available on iOS and Android)</li>\n<li><code>graphics.STATE_CULL_FACE</code></li>\n<li><code>graphics.STATE_POLYGON_OFFSET_FILL</code></li>\n</ul>",
+          "types": ["constant"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Disable face culling when drawing the tile predicate:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">disable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_CULL_FACE</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">tile_pred</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_viewport",
+      "brief": "sets the render viewport",
+      "description": "Set the render viewport to the specified rectangle.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "left corner",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "bottom corner",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "width",
+          "doc": "viewport width",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "height",
+          "doc": "viewport height",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- Set the viewport to the window dimensions.</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_viewport</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=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">())</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.render_target",
+      "brief": "creates a new render target",
+      "description": "Creates a new render target according to the supplied\nspecification table.\nThe table should contain keys specifying which buffers should be created\nwith what parameters. Each buffer key should have a table value consisting\nof parameters. The following parameter keys are available:\n<table>\n<thead>\n<tr>\n<th>Key</th>\n<th>Values</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>format</code></td>\n<td><code>graphics.TEXTURE_FORMAT_LUMINANCE</code><br/><code>graphics.TEXTURE_FORMAT_RGB</code><br/><code>graphics.TEXTURE_FORMAT_RGBA</code><br/><code>graphics.TEXTURE_FORMAT_DEPTH</code><br/><code>graphics.TEXTURE_FORMAT_STENCIL</code><br/><code>graphics.TEXTURE_FORMAT_RGBA32F</code><br/><code>graphics.TEXTURE_FORMAT_RGBA16F</code><br/></td>\n</tr>\n<tr>\n<td><code>width</code></td>\n<td>number</td>\n</tr>\n<tr>\n<td><code>height</code></td>\n<td>number</td>\n</tr>\n<tr>\n<td><code>min_filter</code> (optional)</td>\n<td><code>graphics.TEXTURE_FILTER_LINEAR</code><br/><code>graphics.TEXTURE_FILTER_NEAREST</code></td>\n</tr>\n<tr>\n<td><code>mag_filter</code> (optional)</td>\n<td><code>graphics.TEXTURE_FILTER_LINEAR</code><br/><code>graphics.TEXTURE_FILTER_NEAREST</code></td>\n</tr>\n<tr>\n<td><code>u_wrap</code>     (optional)</td>\n<td><code>graphics.TEXTURE_WRAP_CLAMP_TO_BORDER</code><br/><code>graphics.TEXTURE_WRAP_CLAMP_TO_EDGE</code><br/><code>graphics.TEXTURE_WRAP_MIRRORED_REPEAT</code><br/><code>graphics.TEXTURE_WRAP_REPEAT</code><br/></td>\n</tr>\n<tr>\n<td><code>v_wrap</code>     (optional)</td>\n<td><code>graphics.TEXTURE_WRAP_CLAMP_TO_BORDER</code><br/><code>graphics.TEXTURE_WRAP_CLAMP_TO_EDGE</code><br/><code>graphics.TEXTURE_WRAP_MIRRORED_REPEAT</code><br/><code>graphics.TEXTURE_WRAP_REPEAT</code></td>\n</tr>\n<tr>\n<td><code>flags</code>      (optional)</td>\n<td><code>render.TEXTURE_BIT</code> (only applicable to depth and stencil buffers)</td>\n</tr>\n</tbody>\n</table>\nThe render target can be created to support multiple color attachments. Each attachment can have different format settings and texture filters,\nbut attachments must be added in sequence, meaning you cannot create a render target at slot 0 and 3.\nInstead it has to be created with all four buffer types ranging from [0..3] (as denoted by graphics.BUFFER_TYPE_COLORX_BIT where 'X' is the attachment you want to create).\nIt is not guaranteed that the device running the script can support creating render targets with multiple color attachments. To check if the device can support multiple attachments,\nyou can check if the <code>render</code> table contains any of the <code>BUFFER_TYPE_COLOR1_BIT</code>, <code>BUFFER_TYPE_COLOR2_BIT</code> or <code>BUFFER_TYPE_COLOR3_BIT</code> constants:\n<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=\"kr\">if</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR1_BIT</span> <span class=\"o\">==</span> <span class=\"kc\">nil</span> <span class=\"kr\">then</span>\n        <span class=\"c1\">-- this devices does not support multiple color attachments</span>\n    <span class=\"kr\">end</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "returnvalues": [
+        {
+          "name": "render_target",
+          "doc": "new render target",
+          "types": ["render_target"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "name",
+          "doc": "render target name",
+          "types": ["string"],
+          "is_optional": "False"
+        },
+        {
+          "name": "parameters",
+          "doc": "table of buffer parameters, see the description for available keys and values",
+          "types": ["table"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to create a new render target and draw to it:\n<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=\"c1\">-- render target buffer parameters</span>\n    <span class=\"kd\">local</span> <span class=\"n\">color_params</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">format</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FORMAT_RGBA</span><span class=\"p\">,</span>\n                           <span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span>\n                           <span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">(),</span>\n                           <span class=\"n\">min_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                           <span class=\"n\">mag_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                           <span class=\"n\">u_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span><span class=\"p\">,</span>\n                           <span class=\"n\">v_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span> <span class=\"p\">}</span>\n    <span class=\"kd\">local</span> <span class=\"n\">depth_params</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">format</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FORMAT_DEPTH</span><span class=\"p\">,</span>\n                           <span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span>\n                           <span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">(),</span>\n                           <span class=\"n\">u_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span><span class=\"p\">,</span>\n                           <span class=\"n\">v_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span> <span class=\"p\">}</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">render_target</span><span class=\"p\">({[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">color_params</span><span class=\"p\">,</span> <span class=\"p\">[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_DEPTH_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">depth_params</span> <span class=\"p\">})</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=\"c1\">-- enable target so all drawing is done to it</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- draw a predicate to the render target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\nHow to create a render target with multiple outputs:\n<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=\"c1\">-- render target buffer parameters</span>\n    <span class=\"kd\">local</span> <span class=\"n\">color_params_rgba</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">format</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FORMAT_RGBA</span><span class=\"p\">,</span>\n                                <span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span>\n                                <span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">(),</span>\n                                <span class=\"n\">min_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                                <span class=\"n\">mag_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                                <span class=\"n\">u_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span><span class=\"p\">,</span>\n                                <span class=\"n\">v_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span> <span class=\"p\">}</span>\n    <span class=\"kd\">local</span> <span class=\"n\">color_params_float</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">format</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FORMAT_RG32F</span><span class=\"p\">,</span>\n                           <span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span>\n                           <span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">(),</span>\n                           <span class=\"n\">min_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                           <span class=\"n\">mag_filter</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FILTER_LINEAR</span><span class=\"p\">,</span>\n                           <span class=\"n\">u_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span><span class=\"p\">,</span>\n                           <span class=\"n\">v_wrap</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_WRAP_CLAMP_TO_EDGE</span> <span class=\"p\">}</span>\n\n\n    <span class=\"c1\">-- Create a render target with three color attachments</span>\n    <span class=\"c1\">-- Note: No depth buffer is attached here</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">render_target</span><span class=\"p\">({</span>\n           <span class=\"p\">[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">color_params_rgba</span><span class=\"p\">,</span>\n           <span class=\"p\">[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR1_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">color_params_rgba</span><span class=\"p\">,</span>\n           <span class=\"p\">[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR2_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">color_params_float</span><span class=\"p\">,</span> <span class=\"p\">})</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=\"c1\">-- enable target so all drawing is done to it</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_render_target</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- draw a predicate to the render target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.delete_render_target",
+      "brief": "deletes a render target",
+      "description": "Deletes a render target created by a render script.\nYou cannot delete a render target resource.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "render_target",
+          "doc": "render target to delete",
+          "types": ["render_target"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to delete a render target:\n<div class=\"codehilite\"><pre><span></span><code> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">delete_render_target</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.RENDER_TARGET_DEFAULT",
+      "brief": "",
+      "description": "",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_render_target",
+      "brief": "sets a render target",
+      "description": "Sets a render target. Subsequent draw operations will be to the\nrender target until it is replaced by a subsequent call to set_render_target.\nThis function supports render targets created by a render script, or a render target resource.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "render_target",
+          "doc": "render target to set. render.RENDER_TARGET_DEFAULT to set the default render target",
+          "types": ["render_target"],
+          "is_optional": "False"
+        },
+        {
+          "name": "options",
+          "doc": "optional table with behaviour parameters\n<dl>\n<dt><code>transient</code></dt>\n<dd><span class=\"type\">table</span> Transient frame buffer types are only valid while the render target is active, i.e becomes undefined when a new target is set by a subsequent call to set_render_target.\n Default is all non-transient. Be aware that some hardware uses a combined depth stencil buffer and when this is the case both are considered non-transient if exclusively selected!\n A buffer type defined that doesn't exist in the render target is silently ignored.</dd>\n</dl>\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_DEPTH_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_STENCIL_BIT</code></li>\n</ul>",
+          "types": ["table"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "How to set a render target and draw to it and then switch back to the default render target\nThe render target defines the depth/stencil buffers as transient, when set_render_target is called the next time the buffers may be invalidated and allow for optimisations depending on driver support\n<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- set render target so all drawing is done to it</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">,</span> <span class=\"p\">{</span> <span class=\"n\">transient</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_DEPTH_BIT</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_STENCIL_BIT</span> <span class=\"p\">}</span> <span class=\"p\">}</span> <span class=\"p\">)</span>\n\n    <span class=\"c1\">-- draw a predicate to the render target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- set default render target. This also invalidates the depth and stencil buffers of the current target (self.my_render_target)</span>\n    <span class=\"c1\">--  which can be an optimisation on some hardware</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">RENDER_TARGET_DEFAULT</span><span class=\"p\">)</span>\n\n<span class=\"kr\">end</span>\n</code></pre></div>\n\n<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- set render target by a render target resource identifier</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- draw a predicate to the render target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- reset the render target to the default backbuffer</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">RENDER_TARGET_DEFAULT</span><span class=\"p\">)</span>\n\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_render_target_size",
+      "brief": "sets the render target size",
+      "description": "Sets the render target size for a render target created from\neither a render script, or from a render target resource.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "render_target",
+          "doc": "render target to set size for",
+          "types": ["render_target"],
+          "is_optional": "False"
+        },
+        {
+          "name": "width",
+          "doc": "new render target width",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "height",
+          "doc": "new render target height",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Resize render targets to the current window size:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target_size</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">,</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">())</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target_size</span><span class=\"p\">(</span><span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">,</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">())</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.enable_texture",
+      "brief": "sets a texture to the render state",
+      "description": "Sets the specified texture handle for a render target attachment or a regular texture\nthat should be used for rendering. The texture can be bound to either a texture unit\nor to a sampler name by a hash or a string.\nA texture can be bound to multiple units and sampler names at the same time,\nthe actual binding will be applied to the shaders when a shader program is bound.\nWhen mixing binding using both units and sampler names, you might end up in situations\nwhere two different textures will be applied to the same bind location in the shader.\nIn this case, the texture set to the named sampler will take precedence over the unit.\nNote that you can bind multiple sampler names to the same texture, in case you want to reuse\nthe same texture for differnt use-cases. It is however recommended that you use the same name\neverywhere for the textures that should be shared across different materials.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "binding",
+          "doc": "texture binding, either by texture unit, string or hash for the sampler name that the texture should be bound to",
+          "types": ["number", "string", "hash"],
+          "is_optional": "False"
+        },
+        {
+          "name": "handle_or_name",
+          "doc": "render target or texture handle that should be bound, or a named resource in the \"Render Resource\" table in the currently assigned .render file",
+          "types": ["texture", "string", "hash"],
+          "is_optional": "False"
+        },
+        {
+          "name": "buffer_type",
+          "doc": "optional buffer type from which to enable the texture. Note that this argument only applies to render targets. Defaults to <code>graphics.BUFFER_TYPE_COLOR0_BIT</code>. These values are supported:\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n</ul>\nIf The render target has been created as depth and/or stencil textures, these buffer types can be used:\n<ul>\n<li><code>graphics.BUFFER_TYPE_DEPTH_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_STENCIL_BIT</code></li>\n</ul>\nIf the render target has been created with multiple color attachments, these buffer types can be used\nto enable those textures as well. Currently 4 color attachments are supported:\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_COLOR1_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_COLOR2_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_COLOR3_BIT</code></li>\n</ul>",
+          "types": [
+            "graphics.BUFFER_TYPE_COLOR0_BIT",
+            "graphics.BUFFER_TYPE_COLOR1_BIT",
+            "graphics.BUFFER_TYPE_COLOR2_BIT",
+            "graphics.BUFFER_TYPE_COLOR3_BIT",
+            "graphics.BUFFER_TYPE_DEPTH_BIT",
+            "graphics.BUFFER_TYPE_STENCIL_BIT"
+          ],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- enable target so all drawing is done to it</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- draw a predicate to the render target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n\n    <span class=\"c1\">-- disable target</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">RENDER_TARGET_DEFAULT</span><span class=\"p\">)</span>\n\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n    <span class=\"c1\">-- draw a predicate with the render target available as texture 0 in the predicate</span>\n    <span class=\"c1\">-- material shader.</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\n<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- enable render target by resource id</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_render_target</span><span class=\"p\">(</span><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">RENDER_TARGET_DEFAULT</span><span class=\"p\">)</span>\n\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n    <span class=\"c1\">-- draw a predicate with the render target available as texture 0 in the predicate</span>\n    <span class=\"c1\">-- material shader.</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\n<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- bind a texture to the texture unit 0</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_texture_handle</span><span class=\"p\">)</span>\n    <span class=\"c1\">-- bind the same texture to a named sampler</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"s2\">&quot;my_texture_sampler&quot;</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_texture_handle</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.disable_texture",
+      "brief": "disables a texture on the render state",
+      "description": "Disables a texture that has previourly been enabled.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "binding",
+          "doc": "texture binding, either by texture unit, string or hash that should be disabled",
+          "types": ["texture", "string", "hash"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><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\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_render_target</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n    <span class=\"c1\">-- draw a predicate with the render target available as texture 0 in the predicate</span>\n    <span class=\"c1\">-- material shader.</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n    <span class=\"c1\">-- done, disable the texture</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">disable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_render_target_width",
+      "brief": "retrieve the buffer width from a render target",
+      "description": "Returns the specified buffer width from a render target.",
+      "returnvalues": [
+        {
+          "name": "width",
+          "doc": "the width of the render target buffer texture",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "render_target",
+          "doc": "render target from which to retrieve the buffer width",
+          "types": ["render_target"],
+          "is_optional": "False"
+        },
+        {
+          "name": "buffer_type",
+          "doc": "which type of buffer to retrieve the width from\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_COLOR[x]_BIT</code> (x: [0..3], if supported!)</li>\n<li><code>graphics.BUFFER_TYPE_DEPTH_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_STENCIL_BIT</code></li>\n</ul>",
+          "types": [
+            "graphics.BUFFER_TYPE_COLOR0_BIT",
+            "graphics.BUFFER_TYPE_COLOR1_BIT",
+            "graphics.BUFFER_TYPE_COLOR2_BIT",
+            "graphics.BUFFER_TYPE_COLOR3_BIT",
+            "graphics.BUFFER_TYPE_DEPTH_BIT",
+            "graphics.BUFFER_TYPE_STENCIL_BIT"
+          ],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- get the width of the render target color buffer</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_render_target_width</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">target_right</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n<span class=\"c1\">-- get the width of a render target resource</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_render_target_width</span><span class=\"p\">(</span><span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_render_target_height",
+      "brief": "retrieve a buffer height from a render target",
+      "description": "Returns the specified buffer height from a render target.",
+      "returnvalues": [
+        {
+          "name": "height",
+          "doc": "the height of the render target buffer texture",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "render_target",
+          "doc": "render target from which to retrieve the buffer height",
+          "types": ["render_target"],
+          "is_optional": "False"
+        },
+        {
+          "name": "buffer_type",
+          "doc": "which type of buffer to retrieve the height from\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_DEPTH_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_STENCIL_BIT</code></li>\n</ul>",
+          "types": [
+            "graphics.BUFFER_TYPE_COLOR0_BIT",
+            "graphics.BUFFER_TYPE_COLOR1_BIT",
+            "graphics.BUFFER_TYPE_COLOR2_BIT",
+            "graphics.BUFFER_TYPE_COLOR3_BIT",
+            "graphics.BUFFER_TYPE_DEPTH_BIT",
+            "graphics.BUFFER_TYPE_STENCIL_BIT"
+          ],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- get the height of the render target color buffer</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_render_target_height</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">target_right</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n<span class=\"c1\">-- get the height of a render target resource</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_render_target_height</span><span class=\"p\">(</span><span class=\"s1\">&#39;my_rt_resource&#39;</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.clear",
+      "brief": "clears the active render target",
+      "description": "Clear buffers in the currently enabled render target with specified value. If the render target has been created with multiple\ncolor attachments, all buffers will be cleared with the same value.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "buffers",
+          "doc": "table with keys specifying which buffers to clear and values set to clear values. Available keys are:\n<ul>\n<li><code>graphics.BUFFER_TYPE_COLOR0_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_DEPTH_BIT</code></li>\n<li><code>graphics.BUFFER_TYPE_STENCIL_BIT</code></li>\n</ul>",
+          "types": ["table"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Clear the color buffer and the depth buffer.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">clear</span><span class=\"p\">({[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">]</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=\"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> <span class=\"p\">[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_DEPTH_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">})</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.draw",
+      "brief": "draws all objects matching a predicate",
+      "description": "Draws all objects that match a specified predicate. An optional constant buffer can be\nprovided to override the default constants. If no constants buffer is provided, a default\nsystem constants buffer is used containing constants as defined in materials and set through\n<a href=\"/ref/go#go.set\">go.set</a> (or <a href=\"/ref/particlefx#particlefx.set_constant\">particlefx.set_constant</a>) on visual components.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "predicate",
+          "doc": "predicate to draw for",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "options",
+          "doc": "optional table with properties:\n<dl>\n<dt><code>frustum</code></dt>\n<dd><span class=\"type\">matrix4</span> A frustum matrix used to cull renderable items. (E.g. <code>local frustum = proj * view</code>). default=nil</dd>\n<dt><code>frustum_planes</code></dt>\n<dd><span class=\"type\">int</span> Determines which sides of the frustum will be used. Default is render.FRUSTUM_PLANES_SIDES.</dd>\n</dl>\n<ul>\n<li>render.FRUSTUM_PLANES_SIDES : The left, right, top and bottom sides of the frustum.</li>\n<li>render.FRUSTUM_PLANES_ALL : All 6 sides of the frustum.</li>\n</ul>\n<dl>\n<dt><code>constants</code></dt>\n<dd><span class=\"type\">constant_buffer</span> optional constants to use while rendering</dd>\n<dt><code>sort_order</code></dt>\n<dd><span class=\"type\">int</span> How to sort draw order for world-ordered entries. Default uses the renderer's preferred world sorting (back-to-front).</dd>\n</dl>",
+          "types": ["table"],
+          "is_optional": "True"
+        }
+      ],
+      "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=\"c1\">-- define a predicate matching anything with material tag &quot;my_tag&quot;</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">predicate</span><span class=\"p\">({</span><span class=\"n\">hash</span><span class=\"p\">(</span><span class=\"s2\">&quot;my_tag&quot;</span><span class=\"p\">)})</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=\"c1\">-- draw everything in the my_pred predicate</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\nDraw predicate with constants:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">constant_buffer</span><span class=\"p\">()</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">tint</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\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">,</span> <span class=\"p\">{</span><span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">constants</span><span class=\"p\">})</span>\n</code></pre></div>\n\nDraw with predicate and frustum culling (without near+far planes):\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">frustum</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">proj</span> <span class=\"o\">*</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">view</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">,</span> <span class=\"p\">{</span><span class=\"n\">frustum</span> <span class=\"o\">=</span> <span class=\"n\">frustum</span><span class=\"p\">})</span>\n</code></pre></div>\n\nDraw with predicate and frustum culling (with near+far planes):\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">frustum</span> <span class=\"o\">=</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">proj</span> <span class=\"o\">*</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">view</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">,</span> <span class=\"p\">{</span><span class=\"n\">frustum</span> <span class=\"o\">=</span> <span class=\"n\">frustum</span><span class=\"p\">,</span> <span class=\"n\">frustum_planes</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">FRUSTUM_PLANES_ALL</span><span class=\"p\">})</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.draw_debug3d",
+      "brief": "draws all 3d debug graphics",
+      "description": "Draws all 3d debug graphics such as lines drawn with \"draw_line\" messages and physics visualization.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "options",
+          "doc": "optional table with properties:\n<dl>\n<dt><code>frustum</code></dt>\n<dd><span class=\"type\">matrix4</span> A frustum matrix used to cull renderable items. (E.g. <code>local frustum = proj * view</code>). May be nil.</dd>\n<dt><code>frustum_planes</code></dt>\n<dd><span class=\"type\">int</span> Determines which sides of the frustum will be used. Default is render.FRUSTUM_PLANES_SIDES.</dd>\n</dl>\n<ul>\n<li>render.FRUSTUM_PLANES_SIDES : The left, right, top and bottom sides of the frustum.</li>\n<li>render.FRUSTUM_PLANES_ALL : All sides of the frustum.</li>\n</ul>",
+          "types": ["table"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><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=\"c1\">-- draw debug visualization</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw_debug3d</span><span class=\"p\">()</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "render.draw_debug2d",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_view",
+      "brief": "sets the view matrix",
+      "description": "Sets the view matrix to use when rendering.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "matrix",
+          "doc": "view matrix to set",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to set the view and projection matrices according to\nthe values supplied by a camera.\n<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\">view</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=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">projection</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=\"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=\"c1\">-- set the view to the stored view value</span>\n  <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_view</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">view</span><span class=\"p\">)</span>\n  <span class=\"c1\">-- now we can draw with this view</span>\n<span class=\"kr\">end</span>\n\n<span class=\"kr\">function</span> <span class=\"nf\">on_message</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">message_id</span><span class=\"p\">,</span> <span class=\"n\">message</span><span class=\"p\">)</span>\n  <span class=\"kr\">if</span> <span class=\"n\">message_id</span> <span class=\"o\">==</span> <span class=\"n\">hash</span><span class=\"p\">(</span><span class=\"s2\">&quot;set_view_projection&quot;</span><span class=\"p\">)</span> <span class=\"kr\">then</span>\n     <span class=\"c1\">-- camera view and projection arrives here.</span>\n     <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">view</span> <span class=\"o\">=</span> <span class=\"n\">message</span><span class=\"p\">.</span><span class=\"n\">view</span>\n     <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">projection</span> <span class=\"o\">=</span> <span class=\"n\">message</span><span class=\"p\">.</span><span class=\"n\">projection</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": "render.set_projection",
+      "brief": "sets the projection matrix",
+      "description": "Sets the projection matrix to use when rendering.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "matrix",
+          "doc": "projection matrix",
+          "types": ["matrix4"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to set the projection to orthographic with world origo at lower left,\nwidth and height as set in project settings and depth (z) between -1 and 1:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_projection</span><span class=\"p\">(</span><span class=\"n\">vmath</span><span class=\"p\">.</span><span class=\"n\">matrix4_orthographic</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_width</span><span class=\"p\">(),</span> <span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_height</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>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.FRUSTUM_PLANES_SIDES",
+      "brief": "",
+      "description": "",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.FRUSTUM_PLANES_ALL",
+      "brief": "",
+      "description": "",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.SORT_BACK_TO_FRONT",
+      "brief": "Depth sort far-to-near (default; good for transpar...",
+      "description": "Depth sort far-to-near (default; good for transparent passes).",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.SORT_FRONT_TO_BACK",
+      "brief": "Depth sort near-to-far (good for opaque passes to ...",
+      "description": "Depth sort near-to-far (good for opaque passes to reduce overdraw).",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "CONSTANT",
+      "name": "render.SORT_NONE",
+      "brief": "No per-call sorting; draw entries in insertion ord...",
+      "description": "No per-call sorting; draw entries in insertion order.",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_blend_func",
+      "brief": "sets the blending function",
+      "description": "Specifies the arithmetic used when computing pixel values that are written to the frame\nbuffer. In RGBA mode, pixels can be drawn using a function that blends the source RGBA\npixel values with the destination pixel values already in the frame buffer.\nBlending is initially disabled.\n<code>source_factor</code> specifies which method is used to scale the source color components.\n<code>destination_factor</code> specifies which method is used to scale the destination color\ncomponents.\nSource color components are referred to as (R<sub>s</sub>,G<sub>s</sub>,B<sub>s</sub>,A<sub>s</sub>).\nDestination color components are referred to as (R<sub>d</sub>,G<sub>d</sub>,B<sub>d</sub>,A<sub>d</sub>).\nThe color specified by setting the blendcolor is referred to as (R<sub>c</sub>,G<sub>c</sub>,B<sub>c</sub>,A<sub>c</sub>).\nThe source scale factor is referred to as (s<sub>R</sub>,s<sub>G</sub>,s<sub>B</sub>,s<sub>A</sub>).\nThe destination scale factor is referred to as (d<sub>R</sub>,d<sub>G</sub>,d<sub>B</sub>,d<sub>A</sub>).\nThe color values have integer values between 0 and (k<sub>R</sub>,k<sub>G</sub>,k<sub>B</sub>,k<sub>A</sub>), where k<sub>c</sub> = 2<sup>m<sub>c</sub></sup> - 1 and m<sub>c</sub> is the number of bitplanes for that color. I.e for 8 bit color depth, color values are between <code>0</code> and <code>255</code>.\nAvailable factor constants and corresponding scale factors:\n<table>\n<thead>\n<tr>\n<th>Factor constant</th>\n<th>Scale factor (f<sub>R</sub>,f<sub>G</sub>,f<sub>B</sub>,f<sub>A</sub>)</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ZERO</code></td>\n<td>(0,0,0,0)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE</code></td>\n<td>(1,1,1,1)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_SRC_COLOR</code></td>\n<td>(R<sub>s</sub>/k<sub>R</sub>,G<sub>s</sub>/k<sub>G</sub>,B<sub>s</sub>/k<sub>B</sub>,A<sub>s</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_SRC_COLOR</code></td>\n<td>(1,1,1,1) - (R<sub>s</sub>/k<sub>R</sub>,G<sub>s</sub>/k<sub>G</sub>,B<sub>s</sub>/k<sub>B</sub>,A<sub>s</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_DST_COLOR</code></td>\n<td>(R<sub>d</sub>/k<sub>R</sub>,G<sub>d</sub>/k<sub>G</sub>,B<sub>d</sub>/k<sub>B</sub>,A<sub>d</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_DST_COLOR</code></td>\n<td>(1,1,1,1) - (R<sub>d</sub>/k<sub>R</sub>,G<sub>d</sub>/k<sub>G</sub>,B<sub>d</sub>/k<sub>B</sub>,A<sub>d</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_SRC_ALPHA</code></td>\n<td>(A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA</code></td>\n<td>(1,1,1,1) - (A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>,A<sub>s</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_DST_ALPHA</code></td>\n<td>(A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_DST_ALPHA</code></td>\n<td>(1,1,1,1) - (A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>,A<sub>d</sub>/k<sub>A</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_CONSTANT_COLOR</code></td>\n<td>(R<sub>c</sub>,G<sub>c</sub>,B<sub>c</sub>,A<sub>c</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR</code></td>\n<td>(1,1,1,1) - (R<sub>c</sub>,G<sub>c</sub>,B<sub>c</sub>,A<sub>c</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_CONSTANT_ALPHA</code></td>\n<td>(A<sub>c</sub>,A<sub>c</sub>,A<sub>c</sub>,A<sub>c</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA</code></td>\n<td>(1,1,1,1) - (A<sub>c</sub>,A<sub>c</sub>,A<sub>c</sub>,A<sub>c</sub>)</td>\n</tr>\n<tr>\n<td><code>graphics.BLEND_FACTOR_SRC_ALPHA_SATURATE</code></td>\n<td>(i,i,i,1) where i = min(A<sub>s</sub>, k<sub>A</sub> - A<sub>d</sub>) /k<sub>A</sub></td>\n</tr>\n</tbody>\n</table>\nThe blended RGBA values of a pixel comes from the following equations:\n<ul>\n<li>R<sub>d</sub> = min(k<sub>R</sub>, R<sub>s</sub> * s<sub>R</sub> + R<sub>d</sub> * d<sub>R</sub>)</li>\n<li>G<sub>d</sub> = min(k<sub>G</sub>, G<sub>s</sub> * s<sub>G</sub> + G<sub>d</sub> * d<sub>G</sub>)</li>\n<li>B<sub>d</sub> = min(k<sub>B</sub>, B<sub>s</sub> * s<sub>B</sub> + B<sub>d</sub> * d<sub>B</sub>)</li>\n<li>A<sub>d</sub> = min(k<sub>A</sub>, A<sub>s</sub> * s<sub>A</sub> + A<sub>d</sub> * d<sub>A</sub>)</li>\n</ul>\nBlend function <code>(graphics.BLEND_FACTOR_SRC_ALPHA, graphics.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA)</code> is useful for\ndrawing with transparency when the drawn objects are sorted from farthest to nearest.\nIt is also useful for drawing antialiased points and lines in arbitrary order.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "source_factor",
+          "doc": "source factor",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "destination_factor",
+          "doc": "destination factor",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Set the blend func to the most common one:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_blend_func</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BLEND_FACTOR_SRC_ALPHA</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BLEND_FACTOR_ONE_MINUS_SRC_ALPHA</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_color_mask",
+      "brief": "sets the color mask",
+      "description": "Specifies whether the individual color components in the frame buffer is enabled for writing (<code>true</code>) or disabled (<code>false</code>). For example, if <code>blue</code> is <code>false</code>, nothing is written to the blue component of any pixel in any of the color buffers, regardless of the drawing operation attempted. Note that writing are either enabled or disabled for entire color components, not the individual bits of a component.\nThe component masks are all initially <code>true</code>.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "red",
+          "doc": "red mask",
+          "types": ["boolean"],
+          "is_optional": "False"
+        },
+        {
+          "name": "green",
+          "doc": "green mask",
+          "types": ["boolean"],
+          "is_optional": "False"
+        },
+        {
+          "name": "blue",
+          "doc": "blue mask",
+          "types": ["boolean"],
+          "is_optional": "False"
+        },
+        {
+          "name": "alpha",
+          "doc": "alpha mask",
+          "types": ["boolean"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- alpha cannot be written to frame buffer</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_color_mask</span><span class=\"p\">(</span><span class=\"kc\">true</span><span class=\"p\">,</span> <span class=\"kc\">true</span><span class=\"p\">,</span> <span class=\"kc\">true</span><span class=\"p\">,</span> <span class=\"kc\">false</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_depth_mask",
+      "brief": "sets the depth mask",
+      "description": "Specifies whether the depth buffer is enabled for writing. The supplied mask governs\nif depth buffer writing is enabled (<code>true</code>) or disabled (<code>false</code>).\nThe mask is initially <code>true</code>.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "depth",
+          "doc": "depth mask",
+          "types": ["boolean"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to turn off writing to the depth buffer:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_depth_mask</span><span class=\"p\">(</span><span class=\"kc\">false</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_stencil_mask",
+      "brief": "sets the stencil mask",
+      "description": "The stencil mask controls the writing of individual bits in the stencil buffer.\nThe least significant <code>n</code> bits of the parameter <code>mask</code>, where <code>n</code> is the number of\nbits in the stencil buffer, specify the mask.\nWhere a <code>1</code> bit appears in the mask, the corresponding\nbit in the stencil buffer can be written. Where a <code>0</code> bit appears in the mask,\nthe corresponding bit in the stencil buffer is never written.\nThe mask is initially all <code>1</code>'s.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "mask",
+          "doc": "stencil mask",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- set the stencil mask to all 1:s</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_stencil_mask</span><span class=\"p\">(</span><span class=\"mh\">0xff</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_depth_func",
+      "brief": "sets the depth test function",
+      "description": "Specifies the function that should be used to compare each incoming pixel\ndepth value with the value present in the depth buffer.\nThe comparison is performed only if depth testing is enabled and specifies\nthe conditions under which a pixel will be drawn.\nFunction constants:\n<ul>\n<li><code>graphics.COMPARE_FUNC_NEVER</code> (never passes)</li>\n<li><code>graphics.COMPARE_FUNC_LESS</code> (passes if the incoming depth value is less than the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_LEQUAL</code> (passes if the incoming depth value is less than or equal to the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_GREATER</code> (passes if the incoming depth value is greater than the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_GEQUAL</code> (passes if the incoming depth value is greater than or equal to the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_EQUAL</code> (passes if the incoming depth value is equal to the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_NOTEQUAL</code> (passes if the incoming depth value is not equal to the stored value)</li>\n<li><code>graphics.COMPARE_FUNC_ALWAYS</code> (always passes)</li>\n</ul>\nThe depth function is initially set to <code>graphics.COMPARE_FUNC_LESS</code>.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "func",
+          "doc": "depth test function, see the description for available values",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Enable depth test and set the depth test function to \"not equal\".\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_DEPTH_TEST</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_depth_func</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">COMPARE_FUNC_NOTEQUAL</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_stencil_func",
+      "brief": "sets the stencil test function",
+      "description": "Stenciling is similar to depth-buffering as it enables and disables drawing on a\nper-pixel basis. First, GL drawing primitives are drawn into the stencil planes.\nSecond, geometry and images are rendered but using the stencil planes to mask out\nwhere to draw.\nThe stencil test discards a pixel based on the outcome of a comparison between the\nreference value <code>ref</code> and the corresponding value in the stencil buffer.\n<code>func</code> specifies the comparison function. See the table below for values.\nThe initial value is <code>graphics.COMPARE_FUNC_ALWAYS</code>.\n<code>ref</code> specifies the reference value for the stencil test. The value is clamped to\nthe range [0, 2<sup>n</sup>-1], where n is the number of bitplanes in the stencil buffer.\nThe initial value is <code>0</code>.\n<code>mask</code> is ANDed with both the reference value and the stored stencil value when the test\nis done. The initial value is all <code>1</code>'s.\nFunction constant:\n<ul>\n<li><code>graphics.COMPARE_FUNC_NEVER</code> (never passes)</li>\n<li><code>graphics.COMPARE_FUNC_LESS</code> (passes if (ref &amp; mask) &lt; (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_LEQUAL</code> (passes if (ref &amp; mask) &lt;= (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_GREATER</code> (passes if (ref &amp; mask) &gt; (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_GEQUAL</code> (passes if (ref &amp; mask) &gt;= (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_EQUAL</code> (passes if (ref &amp; mask) = (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_NOTEQUAL</code> (passes if (ref &amp; mask) != (stencil &amp; mask))</li>\n<li><code>graphics.COMPARE_FUNC_ALWAYS</code> (always passes)</li>\n</ul>",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "func",
+          "doc": "stencil test function, see the description for available values",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "ref",
+          "doc": "reference value for the stencil test",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "mask",
+          "doc": "mask that is ANDed with both the reference value and the stored stencil value when the test is done",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- let only 0&#39;s pass the stencil test</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_stencil_func</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">COMPARE_FUNC_EQUAL</span><span class=\"p\">,</span> <span class=\"mi\">0</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": "render.set_stencil_op",
+      "brief": "sets the stencil operator",
+      "description": "The stencil test discards a pixel based on the outcome of a comparison between the\nreference value <code>ref</code> and the corresponding value in the stencil buffer.\nTo control the test, call <a href=\"/ref/render#render.set_stencil_func\">render.set_stencil_func</a>.\nThis function takes three arguments that control what happens to the stored stencil\nvalue while stenciling is enabled. If the stencil test fails, no change is made to the\npixel's color or depth buffers, and <code>sfail</code> specifies what happens to the stencil buffer\ncontents.\nOperator constants:\n<ul>\n<li><code>graphics.STENCIL_OP_KEEP</code> (keeps the current value)</li>\n<li><code>graphics.STENCIL_OP_ZERO</code> (sets the stencil buffer value to 0)</li>\n<li><code>graphics.STENCIL_OP_REPLACE</code> (sets the stencil buffer value to <code>ref</code>, as specified by <a href=\"/ref/render#render.set_stencil_func\">render.set_stencil_func</a>)</li>\n<li><code>graphics.STENCIL_OP_INCR</code> (increments the stencil buffer value and clamp to the maximum representable unsigned value)</li>\n<li><code>graphics.STENCIL_OP_INCR_WRAP</code> (increments the stencil buffer value and wrap to zero when incrementing the maximum representable unsigned value)</li>\n<li><code>graphics.STENCIL_OP_DECR</code> (decrements the current stencil buffer value and clamp to 0)</li>\n<li><code>graphics.STENCIL_OP_DECR_WRAP</code> (decrements the current stencil buffer value and wrap to the maximum representable unsigned value when decrementing zero)</li>\n<li><code>graphics.STENCIL_OP_INVERT</code> (bitwise inverts the current stencil buffer value)</li>\n</ul>\n<code>dppass</code> and <code>dpfail</code> specify the stencil buffer actions depending on whether subsequent\ndepth buffer tests succeed (dppass) or fail (dpfail).\nThe initial value for all operators is <code>graphics.STENCIL_OP_KEEP</code>.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "sfail",
+          "doc": "action to take when the stencil test fails",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "dpfail",
+          "doc": "the stencil action when the stencil test passes",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "dppass",
+          "doc": "the stencil action when both the stencil test and the depth test pass, or when the stencil test passes and either there is no depth buffer or depth testing is not enabled",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Set the stencil function to never pass and operator to always draw 1's\non test fail.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_stencil_func</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">COMPARE_FUNC_NEVER</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"mh\">0xFF</span><span class=\"p\">)</span>\n<span class=\"c1\">-- always draw 1&#39;s on test fail</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_stencil_op</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STENCIL_OP_REPLACE</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STENCIL_OP_KEEP</span><span class=\"p\">,</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STENCIL_OP_KEEP</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_cull_face",
+      "brief": "sets the cull face",
+      "description": "Specifies whether front- or back-facing polygons can be culled\nwhen polygon culling is enabled. Polygon culling is initially disabled.\nIf mode is <code>graphics.FACE_TYPE_FRONT_AND_BACK</code>, no polygons are drawn, but other\nprimitives such as points and lines are drawn. The initial value for\n<code>face_type</code> is <code>graphics.FACE_TYPE_BACK</code>.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "face_type",
+          "doc": "face type\n<ul>\n<li><code>graphics.FACE_TYPE_FRONT</code></li>\n<li><code>graphics.FACE_TYPE_BACK</code></li>\n<li><code>graphics.FACE_TYPE_FRONT_AND_BACK</code></li>\n</ul>",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "How to enable polygon culling and set front face culling:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_CULL_FACE</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_cull_face</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">FACE_TYPE_FRONT</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_polygon_offset",
+      "brief": "sets the polygon offset",
+      "description": "Sets the scale and units used to calculate depth values.\nIf <code>graphics.STATE_POLYGON_OFFSET_FILL</code> is enabled, each fragment's depth value\nis offset from its interpolated value (depending on the depth value of the\nappropriate vertices). Polygon offset can be used when drawing decals, rendering\nhidden-line images etc.\n<code>factor</code> specifies a scale factor that is used to create a variable depth\noffset for each polygon. The initial value is <code>0</code>.\n<code>units</code> is multiplied by an implementation-specific value to create a\nconstant depth offset. The initial value is <code>0</code>.\nThe value of the offset is computed as <code>factor</code> &times; <code>DZ</code> + <code>r</code> &times; <code>units</code>\n<code>DZ</code> is a measurement of the depth slope of the polygon which is the change in z (depth)\nvalues divided by the change in either x or y coordinates, as you traverse a polygon.\nThe depth values are in window coordinates, clamped to the range [0, 1].\n<code>r</code> is the smallest value that is guaranteed to produce a resolvable difference.\nIt's value is an implementation-specific constant.\nThe offset is added before the depth test is performed and before the\nvalue is written into the depth buffer.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "factor",
+          "doc": "polygon offset factor",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "units",
+          "doc": "polygon offset units",
+          "types": ["number"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_state</span><span class=\"p\">(</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">STATE_POLYGON_OFFSET_FILL</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_polygon_offset</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">,</span> <span class=\"mf\">1.0</span><span class=\"p\">)</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_width",
+      "brief": "gets the window width, as specified for the project",
+      "description": "Returns the logical window width that is set in the \"game.project\" settings.\nNote that the actual window pixel size can change, either by device constraints\nor user input.",
+      "returnvalues": [
+        {
+          "name": "width",
+          "doc": "specified window width (number)",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [],
+      "examples": "Get the width of the window.\n<div class=\"codehilite\"><pre><span></span><code><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</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_height",
+      "brief": "gets the window height, as specified for the project",
+      "description": "Returns the logical window height that is set in the \"game.project\" settings.\nNote that the actual window pixel size can change, either by device constraints\nor user input.",
+      "returnvalues": [
+        {
+          "name": "height",
+          "doc": "specified window height",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [],
+      "examples": "Get the height of the window\n<div class=\"codehilite\"><pre><span></span><code><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</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_window_width",
+      "brief": "gets the actual window width",
+      "description": "Returns the actual physical window width.\nNote that this value might differ from the logical width that is set in the\n\"game.project\" settings.",
+      "returnvalues": [
+        {
+          "name": "width",
+          "doc": "actual window width",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [],
+      "examples": "Get the actual width of the window\n<div class=\"codehilite\"><pre><span></span><code><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_window_width</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.get_window_height",
+      "brief": "gets the actual window height",
+      "description": "Returns the actual physical window height.\nNote that this value might differ from the logical height that is set in the\n\"game.project\" settings.",
+      "returnvalues": [
+        {
+          "name": "height",
+          "doc": "actual window height",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [],
+      "examples": "Get the actual height of the window\n<div class=\"codehilite\"><pre><span></span><code><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_window_height</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.predicate",
+      "brief": "creates a new render predicate",
+      "description": "This function returns a new render predicate for objects with materials matching\nthe provided material tags. The provided tags are combined into a bit mask\nfor the predicate. If multiple tags are provided, the predicate matches materials\nwith all tags ANDed together.\nThe current limit to the number of tags that can be defined is <code>64</code>.",
+      "returnvalues": [
+        {
+          "name": "predicate",
+          "doc": "new predicate",
+          "types": ["number"]
+        }
+      ],
+      "parameters": [
+        {
+          "name": "tags",
+          "doc": "table of tags that the predicate should match. The tags can be of either hash or string type",
+          "types": ["table"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Create a new render predicate containing all visual objects that\nhave a material with material tags \"opaque\" AND \"smoke\".\n<div class=\"codehilite\"><pre><span></span><code>local p = render.predicate({hash(&quot;opaque&quot;), hash(&quot;smoke&quot;)})\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.enable_material",
+      "brief": "enables a material",
+      "description": "If another material was already enabled, it will be automatically disabled\nand the specified material is used instead.\nThe name of the material must be specified in the \".render\" resource set\nin the \"game.project\" setting.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "material_id",
+          "doc": "material id to enable",
+          "types": ["string", "hash"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Enable material named \"glow\", then draw my_pred with it.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_material</span><span class=\"p\">(</span><span class=\"s2\">&quot;glow&quot;</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">disable_material</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.disable_material",
+      "brief": "disables the currently enabled material",
+      "description": "If a material is currently enabled, disable it.\nThe name of the material must be specified in the \".render\" resource set\nin the \"game.project\" setting.",
+      "returnvalues": [],
+      "parameters": [],
+      "examples": "Enable material named \"glow\", then draw my_pred with it.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_material</span><span class=\"p\">(</span><span class=\"s2\">&quot;glow&quot;</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">disable_material</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_camera",
+      "brief": "sets the current render camera to be used for rendering",
+      "description": "Sets the current render camera to be used for rendering. If a render camera\nhas been set by the render script, the renderer will be using its projection and view matrix\nduring rendering. If a projection and/or view matrix has been set by the render script,\nthey will not be used until the current render camera has been reset by calling <code>render.set_camera()</code>.\nIf the 'use_frustum' flag in the options table has been set to true, the renderer will automatically use the\ncamera frustum for frustum culling regardless of what frustum is being passed into the render.draw() function.\nNote that the frustum plane option in render.draw can still be used together with the camera.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "camera",
+          "doc": "camera id to use, or nil to reset",
+          "types": ["url", "number", "nil"],
+          "is_optional": "False"
+        },
+        {
+          "name": "options",
+          "doc": "optional table with properties:\n<dl>\n<dt><code>use_frustum</code></dt>\n<dd><span class=\"type\">boolean</span> If true, the renderer will use the cameras view-projection matrix for frustum culling (default: false)</dd>\n</dl>",
+          "types": ["table"],
+          "is_optional": "True"
+        }
+      ],
+      "examples": "Set the current camera to be used for rendering\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_camera</span><span class=\"p\">(</span><span class=\"s2\">&quot;main:/my_go#camera&quot;</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_camera</span><span class=\"p\">(</span><span class=\"kc\">nil</span><span class=\"p\">)</span>\n</code></pre></div>\n\nUse the camera frustum for frustum culling together with a specific frustum plane option for the draw command\n<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">-- The camera frustum will take precedence over the frustum plane option in render.draw</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_camera</span><span class=\"p\">(</span><span class=\"s2\">&quot;main:/my_go#camera&quot;</span><span class=\"p\">,</span> <span class=\"p\">{</span> <span class=\"n\">use_frustum</span> <span class=\"o\">=</span> <span class=\"kc\">true</span> <span class=\"p\">})</span>\n<span class=\"c1\">-- However, we can still customize the frustum planes regardless of the camera option!</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">draw</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">my_pred</span><span class=\"p\">,</span> <span class=\"p\">{</span> <span class=\"n\">frustum_planes</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">FRUSTUM_PLANES_ALL</span> <span class=\"p\">})</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_camera</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_compute",
+      "brief": "set the current compute program",
+      "description": "The name of the compute program must be specified in the \".render\" resource set\nin the \"game.project\" setting. If nil (or no arguments) are passed to this function,\nthe current compute program will instead be disabled.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "compute",
+          "doc": "compute id to use, or nil to disable",
+          "types": ["string", "hash", "nil"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Enable compute program named \"fractals\", then dispatch it.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_compute</span><span class=\"p\">(</span><span class=\"s2\">&quot;fractals&quot;</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">backing_texture</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">dispatch_compute</span><span class=\"p\">(</span><span class=\"mi\">128</span><span class=\"p\">,</span> <span class=\"mi\">128</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_compute</span><span class=\"p\">()</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.dispatch_compute",
+      "brief": "dispatches the currently enabled compute program",
+      "description": "Dispatches the currently enabled compute program. The dispatch call takes three arguments x,y,z which constitutes\nthe 'global working group' of the compute dispatch. Together with the 'local working group' specified in the compute shader\nas a layout qualifier, these two sets of parameters forms the number of invocations the compute shader will execute.\nAn optional constant buffer can be provided to override the default constants. If no constants buffer is provided, a default\nsystem constants buffer is used containing constants as defined in the compute program.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "x",
+          "doc": "global work group size X",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "y",
+          "doc": "global work group size Y",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "z",
+          "doc": "global work group size Z",
+          "types": ["number"],
+          "is_optional": "False"
+        },
+        {
+          "name": "options",
+          "doc": "optional table with properties:\n<dl>\n<dt><code>constants</code></dt>\n<dd><span class=\"type\">constant_buffer</span> optional constants to use while rendering</dd>\n</dl>",
+          "types": ["table"],
+          "is_optional": "True"
+        }
+      ],
+      "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=\"kd\">local</span> <span class=\"n\">color_params</span> <span class=\"o\">=</span> <span class=\"p\">{</span> <span class=\"n\">format</span> <span class=\"o\">=</span> <span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">TEXTURE_FORMAT_RGBA</span><span class=\"p\">,</span>\n                           <span class=\"n\">width</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_width</span><span class=\"p\">(),</span>\n                           <span class=\"n\">height</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">get_window_height</span><span class=\"p\">()}</span>\n    <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">scene_rt</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">render_target</span><span class=\"p\">({[</span><span class=\"n\">graphics</span><span class=\"p\">.</span><span class=\"n\">BUFFER_TYPE_COLOR0_BIT</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">color_params</span><span class=\"p\">})</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\">render</span><span class=\"p\">.</span><span class=\"n\">set_compute</span><span class=\"p\">(</span><span class=\"s2\">&quot;bloom&quot;</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">0</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">backing_texture</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">enable_texture</span><span class=\"p\">(</span><span class=\"mi\">1</span><span class=\"p\">,</span> <span class=\"n\">self</span><span class=\"p\">.</span><span class=\"n\">scene_rt</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">dispatch_compute</span><span class=\"p\">(</span><span class=\"mi\">128</span><span class=\"p\">,</span> <span class=\"mi\">128</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n    <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">set_compute</span><span class=\"p\">()</span>\n<span class=\"kr\">end</span>\n</code></pre></div>\n\nDispatch a compute program with a constant buffer:\n<div class=\"codehilite\"><pre><span></span><code><span class=\"kd\">local</span> <span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">constant_buffer</span><span class=\"p\">()</span>\n<span class=\"n\">constants</span><span class=\"p\">.</span><span class=\"n\">tint</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\">1</span><span class=\"p\">,</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n<span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">dispatch_compute</span><span class=\"p\">(</span><span class=\"mi\">32</span><span class=\"p\">,</span> <span class=\"mi\">32</span><span class=\"p\">,</span> <span class=\"mi\">32</span><span class=\"p\">,</span> <span class=\"p\">{</span><span class=\"n\">constants</span> <span class=\"o\">=</span> <span class=\"n\">constants</span><span class=\"p\">})</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    },
+    {
+      "type": "FUNCTION",
+      "name": "render.set_listener",
+      "brief": "set render's event listener",
+      "description": "Set or remove listener. Currenly only only two type of events can arrived:\n<code>render.CONTEXT_EVENT_CONTEXT_LOST</code> - when rendering context lost. Rending paused and all graphics resources become invalid.\n<code>render.CONTEXT_EVENT_CONTEXT_RESTORED</code> - when rendering context was restored. Rendering still paused and graphics resources still\ninvalid but can be reloaded.",
+      "returnvalues": [],
+      "parameters": [
+        {
+          "name": "callback",
+          "doc": "A callback that receives all render related events.\nPass <code>nil</code> if want to remove listener.\n<dl>\n<dt><code>self</code></dt>\n<dd><span class=\"type\">object</span> The render script</dd>\n<dt><code>event_type</code></dt>\n<dd><span class=\"type\">string</span> Rendering event. Possible values: <code>render.CONTEXT_EVENT_CONTEXT_LOST</code>, <code>render.CONTEXT_EVENT_CONTEXT_RESTORED</code></dd>\n</dl>",
+          "types": ["function(self, event_type)", "nil"],
+          "is_optional": "False"
+        }
+      ],
+      "examples": "Set listener and handle render context events.\n<div class=\"codehilite\"><pre><span></span><code><span class=\"c1\">--- custom.render_script</span>\n<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\">render</span><span class=\"p\">.</span><span class=\"n\">set_listener</span><span class=\"p\">(</span><span class=\"kr\">function</span><span class=\"p\">(</span><span class=\"n\">self</span><span class=\"p\">,</span> <span class=\"n\">event_type</span><span class=\"p\">)</span>\n       <span class=\"kr\">if</span> <span class=\"n\">event_type</span> <span class=\"o\">==</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">CONTEXT_EVENT_CONTEXT_LOST</span> <span class=\"kr\">then</span>\n           <span class=\"c1\">--- Some stuff when rendering context is lost</span>\n       <span class=\"kr\">elseif</span> <span class=\"n\">event_type</span> <span class=\"o\">==</span> <span class=\"n\">render</span><span class=\"p\">.</span><span class=\"n\">CONTEXT_EVENT_CONTEXT_RESTORED</span> <span class=\"kr\">then</span>\n           <span class=\"c1\">--- Start reload resources, reload game, etc.</span>\n       <span class=\"kr\">end</span>\n   <span class=\"kr\">end</span><span class=\"p\">)</span>\n<span class=\"kr\">end</span>\n</code></pre></div>",
+      "replaces": "",
+      "error": "",
+      "tparams": [],
+      "members": [],
+      "notes": [],
+      "language": ""
+    }
+  ],
+  "info": {
+    "namespace": "render",
+    "name": "Render",
+    "brief": "Rendering API documentation",
+    "description": "Rendering functions, messages and constants. The \"render\" namespace is\naccessible only from render scripts.\n\nThe rendering API was originally built on top of OpenGL ES 2.0, and it uses a subset of the\nOpenGL computer graphics rendering API for rendering 2D and 3D computer\ngraphics. Our current target is OpenGLES 3.0 with fallbacks to 2.0 on some platforms.\n\n[icon:attention] It is possible to create materials and write shaders that\nrequire features not in OpenGL ES 2.0, but those will not work cross platform.",
+    "path": "engine/render/src/render/render_script.cpp",
+    "file": "",
+    "notes": [],
+    "language": "Lua"
+  }
+}