{"id":1966,"date":"2017-12-12T09:15:53","date_gmt":"2017-12-12T09:15:53","guid":{"rendered":"https:\/\/www.migenius.com\/?p=1966"},"modified":"2017-12-20T22:46:22","modified_gmt":"2017-12-20T22:46:22","slug":"basic-canvas-operations-in-v8","status":"publish","type":"post","link":"https:\/\/www.migenius.com\/blog\/basic-canvas-operations-in-v8","title":{"rendered":"Basic Canvas Operations in V8"},"content":{"rendered":"<p>RealityServer 5.1 introduced new functionality for working with canvases in V8. In this post I&#8217;m going to show you how to do some basic things like resizing and accessing individual canvas pixels. We&#8217;ll build a fun little command to render a scene and process the result into a piece of interactive ASCII art. Of course, this doesn&#8217;t have much practical utility but it&#8217;s a great way to learn about this new feature!<\/p>\n<p><!--more--><\/p>\n<h3>Rendering ASCII Art<\/h3>\n<div class=\"creativ-shortcode creativ-shortcode-cols  creativ-shortcode-cols-half-half \"><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-a\"><div class=\"creativ-shortcode-col-inner\"><p><a href=\"https:\/\/en.wikipedia.org\/wiki\/ASCII_art\">ASCII Art<\/a> is a way of representing raster images purely by using a combination of standard ASCII characters rather than pixels. This technique was used heavily before raster based displays were common but you can still find many examples today.<\/p>\n<p>We are going to write a new RealityServer command in JavaScript using the <a href=\"https:\/\/rsdoc.migenius.com\/doc\/index.html#\/server_apis\/api\/v8_api\/content\/group__mi__v8.html\">Server-Side V8 API<\/a>. If you haven&#8217;t used the V8 API before, this will also serve as good starting point.<\/p>\n<\/div><\/div><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-b\"><div class=\"creativ-shortcode-col-inner\"><p><iframe loading=\"lazy\" src=\"https:\/\/www.youtube.com\/embed\/jAx6t-PeI-g?rel=0&amp;controls=0&amp;showinfo=0\" width=\"400\" height=\"225\" frameborder=\"0\" allowfullscreen=\"allowfullscreen\"><\/iframe><\/p>\n<\/div><\/div><\/div>\n<h3>Command Boilerplate<\/h3>\n<p>First up we want to bring in some modules we will use in our code. The V8 API uses a system similar to the Node.js require based module system. Let&#8217;s bring in the <em>Scene<\/em> and <em>Utils<\/em> modules for working with our scene data and generating UUIDs respectively.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\nconst Utils = require('Utils');\r\nconst Scene = require('Scene');\r\n<\/pre>\n<p>Next we&#8217;ll construct our command object. This specifies the name of our command, input parameters returns and so on.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\nmodule.exports.command = {\r\n    name: 'example_render_to_ascii',\r\n    description: 'Renders ASCII Art!',\r\n    groups: [ 'render', 'javascript' ],\r\n    arguments: {\r\n        renderer: {\r\n            description: 'Render mode to use.',\r\n            type: 'String',\r\n            default: null\r\n        }\r\n    },\r\n    returns: {\r\n        type: 'String',\r\n        description: 'Our ASCII art.'\r\n    },\r\n    execute: function(args) {\r\n        return 'Implement me!';\r\n    }\r\n};\r\n<\/pre>\n<p>We just have one parameter for now to show the format. You can see the basic layout of a command, we have a name (which is used to call the command over <a href=\"https:\/\/www.migenius.com\/articles\/exploring-the-realityserver-json-rpc-api\">JSON-RPC<\/a>), arguments to define the inputs, a return type finally a function to actually execute which takes a single argument which is a map of the arguments defined in the command.<\/p>\n<div class=\"creativ-shortcode creativ-shortcode-cols  creativ-shortcode-cols-half-half \"><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-a\"><div class=\"creativ-shortcode-col-inner\"><p>You&#8217;ll also notice most items can have a description field. This allows you to document your commands and will be shown to users reviewing the RealityServer command documentation. Even with the minimal information above you start to get a nicely documented command. V8 commands are treated identically to built-in commands, they are just much easier to write. Save your initial command into the <em>v8\/commands<\/em> directory and start RealityServer and when browsing the documentation you should be able to find your command, like the example on the right.<\/p>\n<\/div><\/div><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-b\"><div class=\"creativ-shortcode-col-inner\"><div id=\"attachment_1979\" style=\"width: 410px\" class=\"wp-caption aligncenter\"><a href=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_doc.jpg\"><img aria-describedby=\"caption-attachment-1979\" loading=\"lazy\" class=\"wp-image-1979\" src=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_doc-540x304.jpg\" alt=\"\" width=\"400\" height=\"225\" \/><\/a><\/p>\n<p id=\"caption-attachment-1979\" class=\"wp-caption-text\">Auto-generated Documentation (Click to Enlarge)<\/p>\n<\/div>\n<\/div><\/div><\/div>\n<p>Ok, so we have basic structure and our commands loads. We need to add more parameters to make it useful such as specifying the size of the output, a mapping of brightness to characters and obviously the name of the scene we want to render. Here is the full boiler plate without any real code yet (expand to view).<\/p>\n<div class=\"creativ-shortcode creativ-shortcode-accordion\"><p><div class=\"creativ-shortcode creativ-shortcode-toggle \"><h3 class=\"creativ-shortcode creativ-shortcode-toggle-heading\">V8 Boiler Plate Code<i class=\"toggle-down fa-icon-plus\"><\/i><i class=\"toggle-up fa-icon-minus\"><\/i><\/h3><div class=\"creativ-shortcode creativ-shortcode-toggle-content\"><p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\nconst Utils = require('Utils');\r\nconst Scene = require('Scene');\r\n\r\nmodule.exports.command = {\r\n    name: 'example_render_to_ascii_done',\r\n    description: 'Renders ASCII Art!',\r\n    groups: [ 'render', 'javascript' ],\r\n    arguments: {\r\n        renderer: {\r\n            description: 'Render mode to use.',\r\n            type: 'String',\r\n            default: null\r\n        },\r\n        scene_name : {\r\n            description: 'The name of the scene to render.',\r\n            type: 'String'\r\n        },\r\n        text_width: {\r\n            description: 'Width in characters of the output.',\r\n            type: 'Sint32',\r\n            default: 80\r\n        },\r\n        text_height: {\r\n            description: 'Height in characters of the output.',\r\n            type: 'Sint32',\r\n            default: 24\r\n        },\r\n        character_map: {\r\n            description: 'Characters to map with.',\r\n            type: 'String',\r\n            default: '@#$=*!;:~-,.  '\r\n        }\r\n    },\r\n    returns: {\r\n        type: 'String',\r\n        description: 'String of characters representing the image data.'\r\n    },\r\n    execute: function(args) {\r\n        return 'Implement me!';\r\n    }\r\n};\r\n<\/pre>\n<\/p><\/div><\/div><\/p><\/div>\n<p>If we run the command now we&#8217;ll just get back a rude string asking to be implemented so let&#8217;s add some meat to the main <em>execute<\/em> function.<\/p>\n<h3>Rendering the Canvas<\/h3>\n<p>The following code is what we need to add to the <em>execute<\/em> function to actually get our command to do something. Before rendering an image we want to find out what the resolution is set to on the camera in our scene. We can use the following code for this.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Get the camera resolution and options from the scene\r\nconst scene = new Scene(args.scene_name);\r\nconst camera = scene.camera_instance.item.as('Camera');\r\nconst canvas_resolution_x = camera.resolution_x;\r\nconst canvas_resolution_y = camera.resolution_y;\r\n<\/pre>\n<p>The first line uses the scene name from our arguments to create a <em>Scene<\/em> object, pre-populated with the information from the given scene. We need this since the camera instance and and the camera it references are stored in the scene. In the next line we fetch the camera from the scene&#8217;s camera instance. Then we can retrieve the resolution from the camera. Next we need some unique names for our canvas and render context used to render the scene.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Defaults for items requiring unique names\r\nconst canvas_name = Utils.uuid();\r\nconst render_context_name = Utils.uuid();\r\n<\/pre>\n<p>This uses the <em>uuid<\/em> function in our <em>Utils<\/em> library to make a unique identifier for us. Now we have everything we need to do an actual render, which we can do with the following code.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Render to a canvas so we can manipulate it\r\nconst render_canvas = RS.render_to_canvas({\r\n    canvas_pixel_type: 'Rgb',\r\n    canvas_content: 'result',\r\n    canvas_name: canvas_name,\r\n    canvas_resolution_x: canvas_resolution_x,\r\n    canvas_resolution_y: canvas_resolution_y,\r\n    render_context_name: render_context_name,\r\n    render_context_timeout: 10,\r\n    render_context_options: {},\r\n    renderer: args.renderer,\r\n    scene_name: args.scene_name\r\n});\r\n<\/pre>\n<p>You can refer to the documentation for <a href=\"https:\/\/rsdoc.migenius.com\/?doc=render_to_canvas&amp;prev=doc%3D%26index%3Drender%26prev%3Ddoc%3D\">render_to_canvas<\/a> for more details on the settings. Using the <em>RS<\/em> object we can call any standard RealityServer command, which we do here for rendering. The <em>render_to_canvas<\/em> command returns a <a href=\"https:\/\/rsdoc.migenius.com\/doc\/index.html#\/server_apis\/api\/v8_api\/content\/classCanvas.html\">Canvas<\/a> object which contains the image data we are going to use. Before going further, let&#8217;s check that we actually rendered successfully.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Fetch the numeric result of the last render\r\nresult = RS.get_last_render_result({\r\n    render_context_name: render_context_name,\r\n    scene_name: args.scene_name\r\n});\r\n\r\n\/\/ Make sure our render actually worked before trying to go further\r\nif (result &lt; 0) {\r\n    throw new Error(&quot;Render call returned &quot; + result);\r\n}\r\n<\/pre>\n<p>The <em>get_last_render_result<\/em> command gets a numeric result representing the outcome of the previous render. If this number is negative then something went wrong so we shouldn&#8217;t continue. If all went well we have a valid image to work with.<\/p>\n<h3>Image Manipulation<\/h3>\n<p>Now that we have an image in our canvas we can do things with it. Let&#8217;s start by resizing the image to make it much smaller, since we want to output far fewer characters in our ASCII art than there are pixels in the original image. We can do this easily now in RealityServer 5.1 like this.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Resize the image with a bicubic filter so we can generate one character per pixel\r\nconst canvas = render_canvas.resize('cubic', args.text_width, args.text_height);\r\n<\/pre>\n<p>You can see more detailed in the documentation for the <a href=\"https:\/\/rsdoc.migenius.com\/doc\/index.html#\/server_apis\/api\/v8_api\/content\/classCanvas.html#classCanvas_13061192fd8111205f0c19e921dfdaa3c\">resize<\/a> method on the Canvas, including various filter types. This method returns a new canvas and does not change the original one. With a nice small canvas in hand let&#8217;s loop over all of the pixels and do something to them.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ RealityServer canvases have 0,0 at the bottom left so we need to iterate\r\n\/\/ the lines of the image in reverse to get the right order\r\nfor (var y = canvas.height - 1; y &gt;= 0; y--) {\r\n    for (var x = 0; x &lt; canvas.width - 1; x++) {\r\n        \/\/ Get the color of the pixel from our canvas\r\n        var color = canvas.get_pixel(x, y);\r\n        \/\/ Compute a grey scale color\r\n        var grey = new RS.Math.Color(\r\n            color.ntsc_intensity(),\r\n            color.ntsc_intensity(),\r\n            color.ntsc_intensity()\r\n        );\r\n        \/\/ Set the color of all three channels to the intensity\r\n        canvas.set_pixel(x, y, grey);\r\n    }\r\n}\r\n<\/pre>\n<p>So this isn&#8217;t quite doing our ASCII art yet, however it shows how to iterate over the pixels in our canvas and do something simple. In this case we are just taking the colour and then making a new colour which is a grey scale version and setting it back in the canvas. If we were to return this canvas from the command we&#8217;d have a very small grey scale image. Now that we have all of the pieces, we can change the loop above to actually perform the ASCII art remapping.<\/p>\n<h3>Making Art<\/h3>\n<div class=\"creativ-shortcode creativ-shortcode-cols  creativ-shortcode-cols-half-half \"><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-a\"><div class=\"creativ-shortcode-col-inner\"><p>So, how do we go about converting a pixel in our image into a character to display on the screen? There are actually many methods but we will use a very simple one. We&#8217;ll take the intensity of our pixel and then use that to look up a selection of characters arranged from brightest to darkest.<\/p>\n<p>You can see above we can already obtain the intensity of our colour using the\u00a0<em>ntsc_intensity()<\/em> method on the colour. Assuming our image is already tone-mapped then this will be in the <em>[0-1]<\/em> range so to look up our character we can just multiple our intensity by the length of the character map and round the result into an index.<\/p>\n<\/div><\/div><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-b\"><div class=\"creativ-shortcode-col-inner\"><p><a href=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_remapping.svg\"><img class=\"style-svg\" src=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_remapping.svg\" \/><\/a><\/p>\n<\/div><\/div><\/div>\n<p>So, how do we do this in code. Actually it&#8217;s pretty trivial, here we go, let&#8217;s complete the command by changing our manipulation loop and returning our result. First though let&#8217;s look at the line that does the magic.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ Compute pixel brightness and index into the character map\r\nimage += args.character_map[\r\n    parseInt(color.ntsc_intensity() * character_map_length, 10)\r\n];\r\n<\/pre>\n<p>Here image is actually a string which will be our result and we simply look up the character map supplied in the arguments using the intensity as an index. When constructing the character map, you want to try and put characters that look darker on the screen earlier and those that look brighter later. Now we can put it all together in our loop.<\/p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\n\/\/ String to represent our &quot;image&quot;\r\nvar image = &quot;&quot;;\r\n\r\n\/\/ Loop over the canvas and generate the characters representing the colors\r\n\/\/ RealityServer canvases have 0,0 at the bottom left so we need to iterate\r\n\/\/ the lines of the image in reverse to get the right order of characters\r\nconst character_map_length = args.character_map.length - 1;\r\nconst linebreak_index = canvas.resolution_x - 2;\r\nfor (var y = canvas.height - 1; y &gt;= 0; y--) {\r\n    for (var x = 0; x &lt; canvas.width - 1; x++) {\r\n        \/\/ Get the color of the pixel from our canvas\r\n        var color = canvas.get_pixel(x, y);\r\n        \/\/ Compute pixel brightness and index into the character map\r\n        image += args.character_map[\r\n            parseInt(color.ntsc_intensity() * character_map_length, 10)\r\n        ];\r\n        \/\/ Add newline for the end of every row of the image\r\n        if (x === linebreak_index) image += '\\n';\r\n    }\r\n}\r\n\r\n\/\/ Send back the string representing the image\r\nreturn image;\r\n<\/pre>\n<p>We have had to add a little extra code to insert line breaks in the string so it doesn&#8217;t all come out on a single line. This is fast enough to run interactively and you can see this in the <em>ascii_demo<\/em> application that ships with RealityServer 5.1.\u00a0 So then, here is the complete command in all its glory.<\/p>\n<div class=\"creativ-shortcode creativ-shortcode-accordion\"><p><div class=\"creativ-shortcode creativ-shortcode-toggle \"><h3 class=\"creativ-shortcode creativ-shortcode-toggle-heading\">Full Command Source Code<i class=\"toggle-down fa-icon-plus\"><\/i><i class=\"toggle-up fa-icon-minus\"><\/i><\/h3><div class=\"creativ-shortcode creativ-shortcode-toggle-content\"><p>\n<pre class=\"brush: jscript; title: ; notranslate\" title=\"\">\r\nconst Utils = require('Utils');\r\nconst Scene = require('Scene');\r\n\r\nmodule.exports.command = {\r\n    name: 'example_render_to_ascii',\r\n    description: 'Renders ASCII Art!',\r\n    groups: [ 'render', 'javascript' ],\r\n    arguments: {\r\n        renderer: {\r\n            description: 'Render mode to use.',\r\n            type: 'String',\r\n            default: null\r\n        },\r\n        scene_name : {\r\n            description: 'The name of the scene to render.',\r\n            type: 'String'\r\n        },\r\n        text_width: {\r\n            description: 'Width in characters of the output.',\r\n            type: 'Sint32',\r\n            default: 80\r\n        },\r\n        text_height: {\r\n            description: 'Height in characters of the output.',\r\n            type: 'Sint32',\r\n            default: 24\r\n        },\r\n        character_map: {\r\n            description: 'Characters to map with.',\r\n            type: 'String',\r\n            default: '@#$=*!;:~-,.  '\r\n        }\r\n    },\r\n    returns: {\r\n        type: 'String',\r\n        description: 'String of characters representing the image data.'\r\n    },\r\n    execute: function(args) {\r\n        \/\/ Get the camera resolution and options from the scene\r\n        const scene = new Scene(args.scene_name);\r\n        const camera = scene.camera_instance.item.as('Camera');\r\n        const canvas_resolution_x = camera.resolution_x;\r\n        const canvas_resolution_y = camera.resolution_y;\r\n        \r\n        \/\/ Defaults for items requiring unique names\r\n        const canvas_name = Utils.uuid();\r\n        const render_context_name = Utils.uuid();\r\n\r\n        \/\/ Render to a canvas so we can manipulate it\r\n        const render_canvas = RS.render_to_canvas({\r\n            canvas_pixel_type: 'Rgb',\r\n            canvas_content: 'result',\r\n            canvas_name: canvas_name,\r\n            canvas_resolution_x: canvas_resolution_x,\r\n            canvas_resolution_y: canvas_resolution_y,\r\n            render_context_name: render_context_name,\r\n            render_context_timeout: 10,\r\n            render_context_options: {},\r\n            renderer: args.renderer,\r\n            scene_name: args.scene_name\r\n        });\r\n\r\n        \/\/ Fetch the numeric result of the last render\r\n        result = RS.get_last_render_result({\r\n            render_context_name: render_context_name,\r\n            scene_name: args.scene_name\r\n        });\r\n\r\n        \/\/ Make sure our render actually worked before trying to go further\r\n        if (result &lt; 0) { throw new Error(&quot;Render call returned &quot; + result); } \/\/ Resize the image with a bicubic filter so we can generate one character per pixel const canvas = render_canvas.resize('cubic', args.text_width, args.text_height); \/\/ String to represent our &quot;image&quot; var image = &quot;&quot;; \/\/ Loop over the canvas and generate the characters representing the colors \/\/ RealityServer canvases have 0,0 at the bottom left so we need to iterate \/\/ the lines of the image in reverse to get the right order of characters const character_map_length = args.character_map.length - 1; const linebreak_index = canvas.resolution_x - 2; for (var y = canvas.height - 1; y &gt;= 0; y--) {\r\n            for (var x = 0; x &lt; canvas.width - 1; x++) {\r\n                \/\/ Get the color of the pixel from our canvas\r\n                var color = canvas.get_pixel(x, y);\r\n                \/\/ Compute pixel brightness and index into the character map\r\n                image += args.character_map[\r\n                    parseInt(color.ntsc_intensity() * character_map_length, 10)\r\n                ];\r\n                \/\/ Add newline for the end of every row of the image\r\n                if (x === linebreak_index) image += '\\n';\r\n            }\r\n        }\r\n\r\n        \/\/ Send back the string representing the image\r\n        return image;\r\n    }\r\n};\r\n<\/pre>\n<\/p><\/div><\/div><\/p><\/div>\n<h3>Experimenting<\/h3>\n<p>Now that everything works we can try having a bit of fun. We have exposed the character map as a parameter to the command so we can influence the look and feel of the results simply by changing the string of characters. Since we simply index into the string it can be as long or short as we like. Here are a couple of examples using different character maps.<\/p>\n<div class=\"creativ-shortcode creativ-shortcode-cols  creativ-shortcode-cols-half-half \"><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-a\"><div class=\"creativ-shortcode-col-inner\"><div id=\"attachment_1988\" style=\"width: 410px\" class=\"wp-caption aligncenter\"><a href=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_01.png\"><img aria-describedby=\"caption-attachment-1988\" loading=\"lazy\" class=\"wp-image-1988\" src=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_01-540x398.png\" alt=\"\" width=\"400\" height=\"295\" \/><\/a><\/p>\n<p id=\"caption-attachment-1988\" class=\"wp-caption-text\">@#$%&amp;*!^()=-<\/p>\n<\/div>\n<\/div><\/div><div class=\"creativ-shortcode creativ-shortcode-col creativ-shortcode-col-b\"><div class=\"creativ-shortcode-col-inner\"><div id=\"attachment_1989\" style=\"width: 410px\" class=\"wp-caption aligncenter\"><a href=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_02.png\"><img aria-describedby=\"caption-attachment-1989\" loading=\"lazy\" class=\"wp-image-1989\" src=\"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_02-540x398.png\" alt=\"\" width=\"400\" height=\"295\" \/><\/a><\/p>\n<p id=\"caption-attachment-1989\" class=\"wp-caption-text\">$@B%8&amp;WM#*oahkbdpqwmZO0QLCJUYXzcvunxrjft\/\\|()1{}[]?-_+~&lt;&gt;i!lI;:,&#8221;^`&#8217;.<\/p>\n<\/div>\n<\/div><\/div><\/div>\n<p>The first is the default we use in our example command while the second is taken from Paul Bourke&#8217;s page on\u00a0<a href=\"http:\/\/paulbourke.net\/dataformats\/asciiart\/\">Character representation of grey scale images<\/a>. You can see you can get very different results just by changing this one parameter.<\/p>\n<h3>Summing Up<\/h3>\n<p>RealityServer 5.1 includes a demo application and command based on the ideas discussed in this article so you can check those out without doing any coding but I&#8217;d encourage you to make your own and experiment.<\/p>\n<p>We&#8217;ve covered a lot of ground in this article. Setting up a basic V8 server-side command, performing rendering to canvases, canvas manipulation and ASCII art creation. The technique used here is very simple, there are a lot of more sophisticated ways to generate ASCII art, it&#8217;s well worth a search around. There are a lot of techniques used here you can apply to much more useful situations, but you never know when you might want to navigate your 3D scene on your VT100 terminal.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>RealityServer 5.1 introduced new functionality for working with canvases in V8. In this post I&#8217;m going to show you how to do some basic things like resizing and accessing individual canvas pixels. We&#8217;ll build a fun little command to render a scene and process the result into a piece of interactive ASCII art. Of course, [&hellip;]<\/p>\n","protected":false},"author":2,"featured_media":1967,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"inline_featured_image":false,"spay_email":"","jetpack_publicize_message":"Make ASCII Art in RealityServer and learn about V8 canvases at the same time!","jetpack_is_tweetstorm":false,"jetpack_publicize_feature_enabled":true},"categories":[15,12,30],"tags":[26,14,27],"jetpack_featured_media_url":"https:\/\/www.migenius.com\/migenius\/wp-content\/uploads\/2017\/12\/ascii_feature.jpg","_links":{"self":[{"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/posts\/1966"}],"collection":[{"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/comments?post=1966"}],"version-history":[{"count":20,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/posts\/1966\/revisions"}],"predecessor-version":[{"id":1998,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/posts\/1966\/revisions\/1998"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/media\/1967"}],"wp:attachment":[{"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/media?parent=1966"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/categories?post=1966"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.migenius.com\/wp-json\/wp\/v2\/tags?post=1966"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}