Loads of documentation fixes.

docs/en/manuals/3dgraphics.md

@@ -5,7 +5,7 @@ brief: This manual outlines the 3D support in Defold.
 
 # 3D graphics
 
-Defold is at its core a 3D engine. Even when you work with 2D material only all rendering is done in 3D, but ortographically projected onto the screen.
+Defold is at its core a 3D engine. Even when you work with 2D material only all rendering is done in 3D, but orthographically projected onto the screen.
 
 Defold allows you to utilize full 3D content by including 3D assets, or _Models_ into your collections. You can build games in strictly 3D with only 3D assets, or you can mix 3D and 2D content as you wish.
 

docs/en/manuals/animation.md

@@ -379,7 +379,20 @@ For `gui.animate()` the values are named `gui.EASING_LINEAR`, `gui.EASING_INBACK
 
 ## Custom easing
 
-You can create custom easing curves by defining a `vector` with a set of values and then provide the vector instead of one of the predefined easing constants above:
+You can create custom easing curves by defining a `vector` with a set of values and then provide the vector instead of one of the predefined easing constants above. The vector values express a curve from the start value (`0`) to the target value (`1`). The runtime samples values from the vector and linearly interpolates when calculating values in between the points expressed in the vector.
+
+For example, the vector:
+
+```lua
+local values = { 0, 0.4, 0.2, 0.2, 0.5. 1 }
+local my_easing = vmath.vector(values)
+```
+
+yields the following curve:
+
+![Custom curve](images/animation/custom_curve.png)
+
+The following example causes the y position of a game object to jump between the current position and 200 according to a square curve:
 
 ```lua
 local values = { 0, 0, 0, 0, 0, 0, 0, 0,
@@ -394,6 +407,8 @@ local square_easing = vmath.vector(values)
 go.animate("go", "position.y", go.PLAYBACK_LOOP_PINGPONG, 100, square_easing, 2.0)
 ```
 
+![Square curve](images/animation/square_curve.png)
+
 ## Completion callbacks
 
 All animation functions (`go.animate()`, `gui.animate()`, `gui.play_flipbook()`, `gui.play_spine_anim()`, `spine.play_anim()` and `model.play_anim()`) supports an optional Lua callback function as the last argument. This function will be called when the animation has played to the end. The function is never called for looping animations, nor when an animation is manually canceled via `go.cancel_animations()`. The callback can be used to trigger events on animation completion or to chain multiple animations together.

docs/en/manuals/application-lifecycle.md

@@ -13,7 +13,7 @@ In many cases only a rudimentary understanding of Defold's inner workings is nec
 
 The application starts by initializing everything that is needed to run the engine. It loads the main collection and calls [`init()`](/ref/go#init) on all loaded components that has an `init()` Lua function (script components and GUI components with GUI scripts). This allows you to do custom initialization.
 
-The application then enters the update loop where the application will spend a majority of its lifetime. Each frame, game objects and the components they contain are updated. Any script and GUI script [`update()`](/ref/go#update) functions are called. During the update loop messages are dispatched to its recipients, sounds are played and all graphics is rendered.
+The application then enters the update loop where the application will spend a majority of its lifetime. Each frame, game objects and the components they contain are updated. Any script and GUI script [`update()`](/ref/go#update) functions are called. During the update loop messages are dispatched to their recipients, sounds are played and all graphics are rendered.
 
 At some point the applications lifecycle will come to an end. Before the application quits the engine steps out of the update loop and enters a finalization stage. It prepares all loaded game objects for deletion. All object components’ [`final()`](/ref/go#final) functions are called, which allows for custom cleanup. Then the objects are deleted and the main collection is unloaded.
 

docs/en/manuals/building-blocks.md

@@ -111,7 +111,7 @@ msg.post("my_object#script", "my_message", { my_data = 1 })
 
 ## Custom component properties
 
-Components have type specific properties that you set to alter the component in one way or another. It may be the width and height of a sprite component, or whether a sound component should loop its sound or not during playback. _Script components_, in contrast, allows you to specify custom properties for any purpose. In a script you define a script component simply by adding its definition to the script file:
+Components have type specific properties that you set to alter the component in one way or another. It may be the width and height of a sprite component, or a flag dictating whether a sound component should loop its sound or not during playback. _Script components_, in contrast, allow you to specify custom properties for any purpose. In a script you define a script component simply by adding its definition to the script file:
 
 ```lua
 -- self.health will be automatically set to 100 by default. You can change

docs/en/manuals/collection-factory.md

@@ -53,7 +53,7 @@ When spawning a collection, we can pass property parameters to each game object
 local props = {}
 props[hash("/astronaut")] = { size = 10.0 }
 props[hash("/probe1")] = { color = hash("red") }
-props[hash("/probe1")] = { color = hash("green") }
+props[hash("/probe2")] = { color = hash("green") }
 local astro = collectionfactory.create("#factory", nil, nil, props, nil)
 ...
 ```

docs/en/manuals/collection-proxy.md

@@ -25,7 +25,7 @@ All communication with collection proxies regarding loading and unloading is don
 
 ## Worlds
 
-Through collection proxies is it thus possible to switch the top level collection, or to load more than one top level collection into the engine. When doing so it is important to know that each top level collection is a separate physical world. Physics interactions (collisions, triggers, ray-casts) happens between objects belonging to the same collection. There is no physics interaction happening between objects belonging to different top level collections.
+Through collection proxies is it thus possible to switch the top level collection, or to load more than one top level collection into the engine. When doing so it is important to know that each top level collection is a separate physical world. Physics interactions (collisions, triggers, ray-casts) happen between objects belonging to the same collection. There is no physics interaction happening between objects belonging to different top level collections.
 
 In the following example we have split the game world into two collections that we dynamically load through collection proxies. The loading and unloading of the two collections is controlled by a game object called "loader" that we put in our main collection "worlds". We configure the game to automatically load the "worlds.collection" file at startup (see [Project settings documentation](/manuals/project-settings) for details). The collection "worlds" will hold the "loader" object as well as the GUI elements that allow us to move our character around.
 

docs/en/manuals/extensions.md

@@ -33,7 +33,7 @@ To create a new extension, create a folder in the project root. This folder will
 : This optional folder contains any include files.
 
 *lib*
-: This optional folder contains any compiled libraries that the extension depends on. Library files should be placed in subfolders named by `platform`, or `architecure-platform`, depending on what architectures are supported by your libraries. Supported platforms are `ios`, `android+ and `osx`. Supported `arc-platform` pairs are `armv7-ios`, `arm64-ios`, `armv7-android` and `x86_64-osx`.
+: This optional folder contains any compiled libraries that the extension depends on. Library files should be placed in subfolders named by `platform`, or `architecure-platform`, depending on what architectures are supported by your libraries. Supported platforms are `ios`, `android` and `osx`. Supported `arc-platform` pairs are `armv7-ios`, `arm64-ios`, `armv7-android`, `x86-osx` and `x86_64-osx`.
 
 *res*
 : This optional folder contains any extra resources that the extension depends on. Resource files should be placed in subfolders named by `platform`, or `architecure-platform` just as the "lib" subfolders. A subfolder `common` is also allowed, containing resource files common for all platforms.
@@ -41,7 +41,7 @@ To create a new extension, create a folder in the project root. This folder will
 
 ## A simple example extension
 
-Let's build a very simple extension. First, we create a new root folder *myextension* and add a file *ext.manifest* containing the name of the extension:
+Let's build a very simple extension. First, we create a new root folder *myextension* and add a file *ext.manifest* containing the name of the extension "MyExtension". Note that the name is a C++ symbol and must match the first argument to `DM_DECLARE_EXTENSION` (see below).
 
 ![Manifest](images/extensions/manifest.png)
 
@@ -154,7 +154,7 @@ dmExtension::Result FinalizeMyExtension(dmExtension::Params* params)
 DM_DECLARE_EXTENSION(MyExtension, LIB_NAME, AppInitializeMyExtension, AppFinalizeMyExtension, InitializeMyExtension, 0, 0, FinalizeMyExtension)
 ```
 
-Note the macro `DM_DECLARE_EXTENSION` that is used to declare the various entry points into the extension code. For this simple example, there is no need for any "update" or "on_event" entry points, so `0` is provided in those locations to the macro.
+Note the macro `DM_DECLARE_EXTENSION` that is used to declare the various entry points into the extension code. The first argument `symbol` must match the name specified in *ext.manifest*. For this simple example, there is no need for any "update" or "on_event" entry points, so `0` is provided in those locations to the macro.
 
 Now it is just a matter of building the project (<kbd>Project ▸ Build and Launch</kbd>). This will upload the extension to the extension builder which will produce a custom engine with the new extension included. If the builder encounters any errors, a dialog with the build errors will show.
 
@@ -170,7 +170,9 @@ And that's it! We have created a fully working native extension.
 
 ## The ext.manifest file
 
-Apart from the name of the extension, the manifest file can contain platform specific compile flags, link flags, libs and frameworks. Here is an example:
+Apart from the name of the extension, the manifest file can contain platform specific compile flags, link flags, libs and frameworks. If the *ext.manifest* file does not contain a "platforms" segment, or a platform is missing from the list, the platform you bundle for will still build, but without any extra flags set.
+
+Here is an example:
 
 ```yaml
 name: "AdExtension"

docs/en/manuals/factory.md

@@ -37,7 +37,7 @@ factory.create(component, p)
 : (optional) The world rotation of the new game object. This should be a `quat`.
 
 `[properties]`
-: (optiona) A Lua table with any script property values to initiate the game object with. See the [Script property manual](/manuals/script-properties) for information on script properties.
+: (optional) A Lua table with any script property values to initiate the game object with. See the [Script property manual](/manuals/script-properties) for information on script properties.
 
 `[scale]`
 : (optional) The scale of the spawned game object. The scale can be expressed as a `number` (greater than 0) which specifies uniform scaling along all axis. You can also provide a `vector3` where each component specifies scaling along the corresponding axis.

docs/en/manuals/font.md

@@ -5,7 +5,7 @@ brief: This manual describes how Defold handles fonts and how to bring fonts ont
 
 # Font files
 
-Fonts are used to render label components and text nodes in GUI scenes. Defold supports font files in TrueType, OpenType or BMFont format thad can be added to your project and automatically converted into a graphical format that Defold can render. Two font rendering techniques are available, bitmap and distance field, each with its specific benefits and drawbacks.
+Fonts are used to render label components and text nodes in GUI scenes. Defold supports font files in TrueType, OpenType or BMFont format that can be added to your project and automatically converted into a graphical format that Defold can render. Two font rendering techniques are available, bitmap and distance field, each with its specific benefits and drawbacks.
 
 ## Creating a font
 

docs/en/manuals/gui-clipping.md

@@ -24,7 +24,7 @@ Using a pie node with clipping makes creating the minimap a very easy task:
 
 Now the parent node will act as a "keyhole" down to its children. Only graphics bound by the parent clipping node will show so the parent node will define the graphical outer bounds of the map. We are therefore free to move the map node around and whatever part is currently within the parent bounds will show.
 
-Clipping can be applied to box nodes and pie nodes. Text nodes can not clip other nodes. Two different types of clipping is available and a node can be set to *Visible clipper* which draws the clipper shape, and *Inverted clipper* which inverts how the clipper affects the clipping mask (see below for details).
+Clipping can be applied to box nodes and pie nodes. Text nodes can not clip other nodes. Two different types of clipping are available and a node can be set to *Visible clipper* which draws the clipper shape, and *Inverted clipper* which inverts how the clipper affects the clipping mask (see below for details).
 
 ![Clipping properties](images/clipping/clipping_properties.png)
 

docs/en/manuals/gui-layouts.md

@@ -45,7 +45,7 @@ When editing a GUI scene, all nodes are edited on a particular layout. The curre
 
 ![Editing default layer](images/layouts/layouts_default.png)
 
-You also get visual feedback on whether a node overrides a property on the currently selected layer (other than *Default*) or not. Each change to a node property that you do with a layout selected _overrides_ the property in respect to the *Default* layer. Properties that are overridden are marked in blue. You can click on the blue property name to reset the property to the default value.
+You also get visual feedback on whether a node overrides a property on the currently selected layer (other than *Default*) or not. Each change to a node property that you do with a layout selected _overrides_ the property in respect to the *Default* layout. Properties that are overridden are marked in blue. You can click on the blue property name to reset the property to the default value.
 
 ![Editing with layouts](images/layouts/layouts_modified.png)
 

docs/en/manuals/gui-templates.md

@@ -19,7 +19,7 @@ Now we can add any number of instances of the button to another GUI scene. Creat
 
 ![Add template](images/gui-templates/gui-templates-add-template.png)
 
-Select the GUI scene file to use as template, in this case *button.gui*. You can add any number of nodes, each an instance based on the same template. If we change the template, each instance updates immediately in the editor, reflecting the changes. Notice that all nodes present in the template node is accessible in the *Outline* view. Nodes under a template node are automatically named with a prefix "[template node id]/".
+Select the GUI scene file to use as template, in this case *button.gui*. You can add any number of nodes, each an instance based on the same template. If we change the template, each instance updates immediately in the editor, reflecting the changes. Notice that all nodes present in the template node are accessible in the *Outline* view. Nodes under a template node are automatically named with a prefix "[template node id]/".
 
 ![Node instances](images/gui-templates/gui-templates-instances.png)
 
@@ -27,7 +27,7 @@ The template itself is represented in the node tree with an item: "button" and "
 
 ## Overloading properties
 
-Each instance node can overload any of the properties set in the template. Simply mark the node you wish to edit and change the property you want to alter. Nodes that has any overloaded properties are marked green in the *Outline* view. An overloaded property is marked blue. Click the blue property name to reset the property's value to the default.
+Each instance node can overload any of the properties set in the template. Simply mark the node you wish to edit and change the property you want to alter. Nodes that have any overloaded properties are marked green in the *Outline* view. An overloaded property is marked blue. Click the blue property name to reset the property's value to the default.
 
 ![Overloaded properties](images/gui-templates/gui-templates-overloaded.png)
 

docs/en/manuals/gui.md

@@ -14,7 +14,7 @@ A graphical user interface in Defold is a game object component that you build a
 * It is rendered in a separate pass from the rest of the game, on top of other content.
 * It is rendered against a screen-space coordinate system that is independent of camera view so even if you have a moving camera, your GUI elements will stay put on the screen.
 
-The GUI is not part of the collection’s coordinate system but is rendered independently of the game view. Because of this it is not placed in a particular location in the collection editor, nor does it have a visual representation in the collection editor. However, the GUI component have to reside in a game object that has a location in a collection. Changing that location has no effect on the GUI.
+The GUI is not part of the collection’s coordinate system but is rendered independently of the game view. Because of this it is not placed in a particular location in the collection editor, nor does it have a visual representation in the collection editor. However, GUI components have to reside in a game object that has a location in a collection. Changing that location has no effect on the GUI.
 
 ::: important
 The rendering behavior can be changed in the render script but it is usually desirable to use this arrangement since the user interface is a separate visual "layer" on top of the game view and you usually want HUD items and menus on certain spots on screen.
@@ -72,7 +72,7 @@ Note that the color of the box node will tint the animation. The tint color is m
 ![Tinted texture](images/gui/gui_tinted_texture.png)
 
 ::: sidenote
-Box nodes are always rendered, even if they do not have a texture assigned to them, got an alpha set to `0` or are sized `0,0,0`. Box nodes should always have a texture assigned to the. If you need an empty node, set its size to `0,0,0` and make sure to assign a texture to it.
+Box nodes are always rendered, even if they do not have a texture assigned to them, have their alpha set to `0`, or are sized `0, 0, 0`. Box nodes should always have a texture assigned to them so the renderer can batch them properly and reduce the number of draw-calls.
 :::
 
 ## Slice-9 texturing

docs/en/manuals/input.md

@@ -18,7 +18,7 @@ Defold supports the following input device types:
 On Windows, only XBox 360 controllers are currently supported. To hook up your 360 controller to your Windows machine, make sure it is setup correctly. See http://www.wikihow.com/Use-Your-Xbox-360-Controller-for-Windows
 :::
 
-All user input is captured by the engine and dispatched as actions to script- and GUI script components in game objects that has acquired input focus and that implements the `on_input()` function.
+All user input is captured by the engine and dispatched as actions to script- and GUI script components in game objects that have acquired input focus and that implement the `on_input()` function.
 
 Before the input reaches your script it is translated through input bindings into meaningful actions:
 
@@ -40,7 +40,7 @@ There are five types of triggers that you can create. They are device specific:
 4. `touch_trigger` is for all types of touch input.
 5. `text_trigger` is for text input.
 
-Right click on a trigger type and select <kbd>Add [TYPE]_trigger...</kbd> to add a new trigger. Each trigger has two fields:
+Right click on a trigger type and select <kbd>Add [TYPE]\_trigger...</kbd> to add a new trigger. Each trigger has two fields:
 
 *input*
 : A scroll list with the available inputs to listen to.
@@ -79,7 +79,7 @@ msg.post(".", "release_input_focus")
 
 ## on_input()
 
-To react on input actions, you need a component in your game object (that has acquired input focus) with a script and an `on_input()` function. The engine will then dispatch input actions to the function.
+To react to input actions, you need a component in your game object (that has acquired input focus) with a script and an `on_input()` function. The engine will then dispatch input actions to the function.
 
 ```lua
 function on_input(self, action_id, action)

docs/en/manuals/ios.md

@@ -5,7 +5,7 @@ brief: This manual explains how to develop games and apps for iOS devices in Def
 
 # iOS development
 
-iOS development differs from Android development in that you have to be a registered developer to be able to put apps or games on an iOS device, even during development. iOS requires that all apps that are out on a phone or tablet is signed with an Apple-issued certificate and provisioning profile.
+iOS development differs from Android development in that you have to be a registered developer to be able to put apps or games on an iOS device, even during development. iOS requires that all apps that are out on a phone or tablet are signed with an Apple-issued certificate and provisioning profile.
 
 ## Apple's code signing process
 

docs/en/manuals/material.md

@@ -23,7 +23,9 @@ Let's start by creating a simple flat (with no directional light), but textured
 
 ![Material editor](images/materials/materials_material_editor.png)
 
-Now you need to create the vertex and fragment shader program files. Currently, the process is a little bit cumbersome:
+Now you need to create the vertex and fragment shader program files. If you work in Editor 2, just right click the target folder and select the menu <kbd>New... ▸ Vertex Program</kbd> and <kbd>New... ▸ Fragment Program</kbd>.
+
+In Editor 1, the process is a little bit cumbersome:
 
 1. Create a script file by selecting <kbd>File ▸ New... ▸ Script File</kbd>.
 2. Rename the script file so it will have a *.vp* (Vertex Program) suffix.

docs/en/manuals/message-passing.md

@@ -46,7 +46,7 @@ Some of this game content will live in separate files in the project. For instan
 
 The Defold editor will automatically assign unique id:s within the current collection when you place a collection or game object. You can change these names to whatever you like--the editor will keep track of the id:s and make sure that names don't collide. If you force a name collision, the Defold editor will signal an error.
 
-All addresses are expressed by an *URL* that uniquely identify each message sender and receiver in the running game. The URL consists of three components and is written in the following generic format:
+All addresses are expressed by a *URL* that uniquely identify each message sender and receiver in the running game. The URL consists of three components and is written in the following generic format:
 
 `[socket:][path][#fragment]`
 
@@ -84,7 +84,7 @@ In most cases, the above way of writing full URL:s is unnecessary and way too sp
 ![Message passing](images/message_passing/message_passing.png)
 
 Message 1
-: A `knock` message is sent from the "hero" script component to the "enemy" script component. Since both objects live in the same place in the collection hierarchy, their socket ("world", root, or main collection) are the same. We can leave out that piece of information which gives the following call:
+: A `knock` message is sent from the "hero" script component to the "enemy" script component. Since both objects live in the same place in the collection hierarchy, their sockets ("world", root, or main collection) are the same. We can leave out that piece of information which gives the following call:
 
   ```lua
   -- Send "knock" from the script component in "hero" to script in "enemy"
@@ -108,7 +108,7 @@ Message 1
   This is perfectly valid. By leaving out the target component, the message is _broadcast_ to all components in the specified game object. We encourage though that you do specify the component, mainly because broadcasting is less performant but also because it can lead to obscure bugs.
 
 Message 2
-: An `increase_score` message is sent from the "hero" game object's script component to the script component of the "interface" game object.
+: A `increase_score` message is sent from the "hero" game object's script component to the script component of the "interface" game object.
 
   ```lua
   -- Send "increase_score" from the script component in "hero" to script component in "interface"
@@ -125,7 +125,7 @@ Message 2
   Again, notice the lack of initial "/". By using a relative id, the sender and receiver will be able to communicate wherever they live in the collection hierarchies, which is vital when building objects and object hierarchies that are instanced multiple times or dynamically spawned.
 
 Message 3
-: An `update_minimap` message is sent from the "enemy" game object to the "gui" script in the "interface" game object.
+: A `update_minimap` message is sent from the "enemy" game object to the "gui" script in the "interface" game object.
 
   ```lua
   -- Send "update_minimap" from the script component in "enemy" to the GUI script in "interface".
@@ -139,10 +139,10 @@ Message 3
 We have seen how it is possible to leave out redundant information from the URL:s when constructing messages. In addition, Defold provides two handy shorthands that you can use:
 
 `.`
-: An URL shorthand for the current game object.
+: A URL shorthand for the current game object.
 
 `#`
-: An URL shorthand for the current script.
+: A URL shorthand for the current script.
 
 For example:
 

docs/en/manuals/model.md

@@ -5,7 +5,7 @@ brief: This manual describes how to bring 3D models, skeletons and animations in
 
 # Model component
 
-Defold is at its core a 3D engine. Even when you work with 2D material only all rendering is done in 3D, but ortographically projected onto the screen.  Defold allows you to utilize full 3D content by including 3D assets, or _Models_ into your collections. You can build games in strictly 3D with only 3D assets, or you can mix 3D and 2D content as you wish.
+Defold is at its core a 3D engine. Even when you work with 2D material only all rendering is done in 3D, but orthographically projected onto the screen.  Defold allows you to utilize full 3D content by including 3D assets, or _Models_ into your collections. You can build games in strictly 3D with only 3D assets, or you can mix 3D and 2D content as you wish.
 
 ## Creating a model
 

docs/en/manuals/project-settings.md

@@ -71,6 +71,9 @@ custom_resources (hidden setting)
 bundle_resources (hidden setting)
 : A directory containing resource files and folders that should be copied as-is into the resulting package when bundling. The directory is specified with an absolute path from the project root, for example `/res`. The resource directory should contain subfolders named by `platform`, or `architecure-platform`. Supported platforms are `ios`, `android` and `osx`. Supported arc-platform pairs are `armv7-ios`, `arm64-ios`, `armv7-android` and `x86_64-osx`. A subfolder named `common` is also allowed, containing resource files common for all platforms.
 
+bundle_exclude_resources (hidden setting)
+: A comma separated list of resources that should not be included in the bundle.
+
 ## Bootstrap
 
 main_collection

docs/en/manuals/properties.md

@@ -59,14 +59,14 @@ Legacy functions for reading and writing game object properties also exist. They
 | *position* | The local position of the game object. | `vector3`.      | `get+set`{.mark} |
 | *rotation* | Local rotation of game object, expressed as quaternion.  | `quaternion` | `get+set`{.mark} |
 | *euler*    | Local rotation of game object, Euler angles. | `vector3` | `get+set`{.mark} |
-| *scale*    | Local uniform scale of the game object, multiplier. | `number` | `get+set`{.mark} |
+| *scale*    | Local non uniform scale of the game object, expressed as a vector where each component contains a multiplier along each axis. To double the size in x and y, provide vmath.vector3(2.0, 2.0, 0) | `vector3` | `get+set`{.mark} |
 
 *SPRITE COMPONENT PROPERTIES*
 
 | property   | description                            | type            |                  |
 | ---------- | -------------------------------------- | --------------- | ---------------- |
-| *size*.    | The non scaled size of the sprite--its size as taken from the source atlas. | `vector3` | `get`{.mark} |
-| *scale* | Non uniform scaling of the sprite, expressed as a vector where each component contains a multiplier along each axis. To double the size in x and y, provide vmath.vector3(2.0, 2.0, 0) | `vector3` | `get+set`{.mark}|
+| *size*     | The non scaled size of the sprite---its size as taken from the source atlas. | `vector3` | `get`{.mark} |
+| *scale* | Non uniform scale of the sprite. | `vector3` | `get+set`{.mark}|
 
 *COLLISION OBJECT COMPONENT PROPERTIES*
 
@@ -84,7 +84,7 @@ Legacy functions for reading and writing game object properties also exist. They
 | ---------- | -------------------------------------- | --------------- | ---------------- |
 | *animation* | The current animation. | `hash` | `get`{.mark} |
 | *skin*.     | The currently applied model skin. (cannot be animated!) | `hash` | `get+set`{.mark} |
-| *cursor*   | The current position (between 0-1) of the animation playback cursor. | `number` | get+set`{.mark} |
+| *cursor*   | The current position (between 0-1) of the animation playback cursor. | `number` | `get+set`{.mark} |
 | *playback_rate* | The playback rate of the animation. A multiplier to the animation playback rate. | `number` | `get+set`{.mark} |
 
 *MODEL (3D) COMPONENT PROPERTIES*

docs/en/manuals/push.md

@@ -176,8 +176,15 @@ badge_count
 : (iOS only). The numeric value of the icon badge. Set to 0 to clear the badge.
 
 priority
-: (Android only). The priority is a hint to the device UI about how the notification should be displayed. There are five priority levels, from -2 to 2 where -1 is the lowest priority and 2 the highest. Unless specified, a default priority level of 2 is used.
-
+: (Android only). The priority is a hint to the device UI about how the notification should be displayed. There are five priority levels:
+
+  - push.PRIORITY_MIN
+  - push.PRIORITY_LOW
+  - push.PRIORITY_DEFAULT
+  - push.PRIORITY_HIGH
+  - push.PRIORITY_MAX
+  
+  Unless specified, the max priority level is used.
 
 ## Inspecting scheduled notifications
 

docs/en/manuals/scene-editing.md

@@ -37,7 +37,7 @@ To move objects, use the *Move Tool*. It is accessible through the menu <kbd>Sce
 
 ![Scene menu](images/scene_editing/scene_editing_scene.png)
 
-The selected object now shows three manipulation points that are used to move the object. Click and drag in the gren square to move the object freely:
+The selected object now shows three manipulation points that are used to move the object. Click and drag in the green square to move the object freely:
 
 ![Move object](images/scene_editing/scene_editing_move.png)
 

docs/en/manuals/script-properties.md

@@ -7,7 +7,7 @@ brief: This manual explains how to add and use custom properties with script com
 
 Script properties provide a simple and powerful way of exposing properties that control the behavior or look of a specific game object instance and allow non coders to change them in the editor.
 
-Script properties allow for instance specific overrides of script properties. Common use cases is to set the health or speed of a specific enemy AI, the tint color of a pickup object, or what message a button object should send when pressed--and where to send it. There are many cases where script properties are very useful:
+Script properties allow for instance specific overrides of script properties. Common use cases are to set the health or speed of a specific enemy AI, the tint color of a pickup object, or what message a button object should send when pressed---and where to send it. There are many cases where script properties are very useful:
 
 * When you want to override their values for specific instances in the editor, and thereby increase script re-usability.
 * When you want to spawn a game object with initial values.
@@ -15,7 +15,7 @@ Script properties allow for instance specific overrides of script properties. Co
 * When you want to access the data in one script from another.
 
 ::: sidenote
-If access the data frequently, it is better to access it from a table rather than from properties in a foreign script for performance reasons.
+If you access the data frequently, it is better to access it from a local table rather than from properties in a foreign script component for performance reasons.
 :::
 
 Most types of values that you use to control script behavior or component properties can be exposed as script properties:
@@ -59,7 +59,7 @@ function on_message(self, message_id, message, sender)
 end
 ```
 
-If the health reaches `0`, the script destroys the game object. Now suppose that you want to use the script in two different game objects, but want the game objects to have different amounts of health. With the function [`go.property()`](/ref/go#go.property) you can declare the property a script property and it will be set by the specific game object instance:
+If the health reaches `0`, the script destroys the game object. Now suppose that you want to use the script in two different game objects, but want the game objects to have different amounts of health. With the function [`go.property()`](/ref/go#go.property) you can declare a script property and it will be stored in the specific script component instance:
 
 ```lua
 -- self.health will be automatically set to 100 by default
@@ -75,12 +75,12 @@ function on_message(self, message_id, message, sender)
 end
 ```
 
-Any game object that includes the script can set the value specifically. Simply select the script node in the *Outline* view in the editor and the property appears in the *Properties* view allowing you to edit it:
+Any script component instance that uses the script can set the value specifically. Simply select the script component in the *Outline* view in the editor and the property appears in the *Properties* view allowing you to edit it:
 
 ![Script Properties](images/script_properties/script_properties.png)
 
 ::: sidenote
-In the case where you have the game object inside a sub-collection, expand the game object node in the collection to select the script.
+In the case where the game object holding the script lives inside a sub-collection, expand the game object node in the collection to select the script.
 :::
 
 The editor property inspector will automatically show a widget that is feasible for the type of property that you have declared. Numbers are entered in text boxes, vectors and quartenions as a set of numbers in boxes, hashes allow you to enter the string that will be hashed and URLs give you a drop down with all _relative_, local (that is, within the same collection) objects and components. You are still able to enter URL values manually, too.

docs/en/manuals/shader.md

@@ -48,7 +48,7 @@ Note that the vertex shader cannot create or delete vertices, just change vertex
 
 ## Variables
 
-A shader program consists of code that operate on data. Data is passed to and between shader programs through variables of different type:
+A shader program consists of code that operates on data. Data is passed to and between shader programs through variables of different types:
 
 Vertex attribute variables
 : Vertex attributes are used to send data to the vertex shader. Values are set per vertex and contain information about each vertex' position, normal, color and texture coordinate. These values are usually stored in the mesh created in a 3D modelling software and exported to Collada files that Defold can read.
@@ -80,7 +80,7 @@ Uniform variables
 : A vector4 constant that you can use for any custom data you want to pass into your shader programs. You can set the initial value of the constant in the constant definition, but it is mutable through the functions `.set_constant()` and `.reset_constant()` for each component type (`sprite`, `model`, `spine`, `particlefx` and `tilemap`)
 
 Varying variables
-: Varying variables gives you an interface between the vertex and fragment shader. It is the output of a vertex shader and the input of a fragment shader. Varying variables are declared withe the `varying` qualifier and can be of type `float`, `vec2`, `vec3`, `vec4`, `mat2`, `mat3` and `mat4`.
+: Varying variables gives you an interface between the vertex and fragment shader. It is the output of a vertex shader and the input of a fragment shader. Varying variables are declared with the `varying` qualifier and can be of type `float`, `vec2`, `vec3`, `vec4`, `mat2`, `mat3` and `mat4`.
 
 If you define a varying variable and set its value in the vertex shader, the value will be set for each vertex. During rasterization this value is interpolated for each fragment on the primitive being rendered. You can access the interpolated value in the fragment shader to determine what color to set on the fragment.
 

docs/en/manuals/sound.md

@@ -68,7 +68,7 @@ The groups are identified with a hash value. The string name can be retrieved wi
 ![Sound group mixer](images/sound/sound_mixer.png)
 
 ::: important
-You should not write code that rely on the string value of a sound group since it is not available in release builds.
+You should not write code that relies on the string value of a sound group since it is not available in release builds.
 :::
 
 All values are linear between 0 and 1.0 (0 dB). To convert to decibel, simply use the standard formula:

docs/en/manuals/texture-profiles.md

@@ -7,7 +7,11 @@ brief:  Defold supports automatic texture processing and compression of image da
 
 Defold supports automatic texture processing and compression of image data (in *Atlas*, *Tile sources*, *Cubemaps* and stand-alone textures used for models, GUI etc).
 
-There are two types of compression, hardware texture compression and software image compression. Hardware texture compression reduce memory footprint and graphics hardware is able to manage compressed textures. Both hardware texture compression and software image compression reduces the size of image resources and the final bundle size. It should be noted that for example PNG file compression can sometimes yield smaller files, but PNG files need to be uncompressed when read into memory.
+There are two types of compression, software image compression and hardware texture compression. 
+
+1. Software compression (such as PNG and JPEG) reduces the storage size of image resources. This makes the the final bundle size smaller. However, the image files need to be uncompressed when read into memory so even though an image is small on disk, it can have a large memory footprint.
+ 
+2. Hardware texture compression also reduces the storage size of image resources. But, unlike software compression, it reduces the in-memory footprint for textures. This is because the graphics hardware is able to directly manage compressed textures without first having to uncompress them.
 
 The processing of textures is configured through a specific texture profile. In this file you create _profiles_ that express what compressed format(s) and type should be used when creating bundles for a specific platform. _Profiles_ are then tied to matching file _paths patterns_, allowing fine tuned control over what files in your project should be compressed and exactly how.
 

docs/en/manuals/workflow.md

@@ -115,7 +115,7 @@ To open a file in the text editor, right-click the file in the Project view and
 
 Note that Defold remembers the choice of editor for the particular file. If you open a file with the Text Editor, subsequent double clicks on the file in the Project view will automatically open the file in the Text Editor. To reset the selected editor for the file, simply right-click the file and select <kbd>Open With ▸ [Filetype Editor]</kbd> where [Filetype Editor] is the type of editor used for the file type (e.g. Scene Editor for Game Objects, Tile Source Editor for Tile Sources and so forth).
 
-Extra care should be taken when working with files through the Text Editor. Easy to make errors can prevent the file from being possible to open in the designated editor. For instance, suppose you edit a Game Object file and omits an end-quote character in one of the names:
+Extra care should be taken when working with files through the Text Editor. Easy to make errors can prevent the file from being possible to open in the designated editor. For instance, suppose you edit a Game Object file and omit an end-quote character in one of the names:
 
 ![Missing Quote](images/workflow/workflow_texteditor_noquote.png)
 

docs/en/tutorials/car.md

@@ -57,7 +57,7 @@ The "Empty" project template actually isn't completely empty. As you've already
 
 It's perhaps not very exciting, but it's a running Defold game application and we can easily modify it into something more interesting. So let's do that.
 
-First of all, let's clean the file *main.collection* of the one game object it contains. Select "go" in the *Outline* view, right-click and select *Delete*. That's it. If you run the game again, the application window will be totally black.
+First of all, let's clean the file *main.collection* of the one game object it contains. Select "logo" in the *Outline* view, right-click and select *Delete*. That's it. If you run the game again, the application window will be totally black.
 
 ![Delete game object](images/car/start_delete_go.png)
 
@@ -103,7 +103,7 @@ Default Animation
 
 ## Completing the car
 
-Continue by adding two more game objects in the collection. Call them "left_wheel" and "right_wheel" and put a sprite component in each, showing the tire image that we added to *sprited.atlas*. Then grab the wheel game objects and drop them onto "car" to make them children under "car". Game objects that are children under other game objects will be attached to their parent when the parent moves. They can be moved individually as well, but all motion happens relative to the parent object. For the tires this is perfect since we want them to stick to the car and we can just rotate them slightly left and right as we steer the car. A collection can contain any number of game objects, side by side or arranged into complex parent-child trees, or a mix.
+Continue by adding two more game objects in the collection. Call them "left_wheel" and "right_wheel" and put a sprite component in each, showing the tire image that we added to *sprites.atlas*. Then grab the wheel game objects and drop them onto "car" to make them children under "car". Game objects that are children under other game objects will be attached to their parent when the parent moves. They can be moved individually as well, but all motion happens relative to the parent object. For the tires this is perfect since we want them to stick to the car and we can just rotate them slightly left and right as we steer the car. A collection can contain any number of game objects, side by side or arranged into complex parent-child trees, or a mix.
 
 Move the tire game objects into place by selecting them and then choosing <kbd>Scene ▸ Move Tool</kbd>. Grab the arrow handlebars, or the center green square to move the object to a good spot. The final thing we need to do is to make sure that the tires are drawn below the car. We do that by setting the Z component of the position to -0.5. Every visual item in a game is drawn from the back to front, sorted on their Z value. An object with a Z-value of 0 will be drawn on top of an object with a Z-value of -0.5. Since the default Z-value of the car game object is 0, the new value on the tire objects will put them under the car image.
 
@@ -111,7 +111,7 @@ Move the tire game objects into place by selecting them and then choosing <kbd>S
 
 The last piece of the puzzle is a _script_ to control the car. A script is a component that contains a program that defines game object behaviors. With scripts you can specify the rules of your game, how objects should respond to various interactions (with the player as well as other objects). All scripts are written in the Lua programming language. To be able to work with Defold, you or someone on your team needs to learn how to program in Lua.
 
-Mark "main" in the *Project Explorer*, right-click and select <kbd>New ▸ Script File</kbd>. Name the new file *car.script*, then add it to the "car" game object by marking "car" in the *Outline* view, right click and select <kbd>Add Component From File</kbd>. Select *car.script* and click *OK*. Save the collection file.
+Mark "main" in the *Project Explorer*, right-click and select <kbd>New ▸ Script File</kbd>. Name the new file *car.script*, then add it to the "car" game object by marking "car" in the *Outline* view, right click and select <kbd>Add Component File</kbd>. Select *car.script* and click *OK*. Save the collection file.
 
 Double click *car.script* and edit the script so it contains the following:
 
@@ -265,6 +265,6 @@ Now, select <kbd>Project ▸ Build And Launch</kbd> from the main menu and take
 
 If you want you can try to add more instances of *car.collection* to *main.collection*. Each instance is a clone of what's inside *car.collection* with the exact same behavior. Each one listens to input and reacts to the same messages.
 
-That concludes this introductory tutorial. Now go ahead and dive into Defold. We have lots of [manuals and tutorials](/learn) prepared to guide you, and if you get stuck, your're welcome to the [forum](//forum.defold.com).
+That concludes this introductory tutorial. Now go ahead and dive into Defold. We have lots of [manuals and tutorials](/learn) prepared to guide you, and if you get stuck, you are very welcome to the [forum](//forum.defold.com).
 
 Happy Defolding!

docs/en/tutorials/magic-link.md

@@ -284,7 +284,7 @@ Now that we have a board, we should add user interaction. First, we define the i
 
 ![Input bindings](images/magic-link/linker_input_bindings.png)
 
-We only need one binding and we're assigning `MOUSE_BUTTON_LEFT` to the action name "touch". This game don't use multi touch and as a convenience, Defold translates one finger touch input into left mouse clicks.
+We only need one binding and we're assigning `MOUSE_BUTTON_LEFT` to the action name "touch". This game doesn't use multi touch and as a convenience, Defold translates one finger touch input into left mouse clicks.
 
 The job of dealing with the input falls on the board, so we need to add code for that in *board.script*:
 
@@ -757,7 +757,10 @@ function on_input(self, action_id, action)
         end
         self.chain = {}
         -- Empty chain clears connector graphics.
-        connect_chain(self, x, y)
+        for i, c in ipairs(self.connectors) do
+            go.delete(c)
+        end
+        self.connectors = {}
     end
 ```
 
@@ -946,7 +949,10 @@ function on_input(self, action_id, action)
         end
         self.chain = {}
         -- Empty chain clears connector graphics.
-        connect_chain(self, x, y)
+        for i, c in ipairs(self.connectors) do
+            go.delete(c)
+        end
+        self.connectors = {}
     end
 ```
 

docs/en/tutorials/platformer.md

@@ -44,8 +44,6 @@ We assume that you're familiar with a bit of vector mathematics (linear algebra)
 
 If you are already using Defold, you can create a new project based on the _Platformer_ template-project and play around with that while reading this article.
 
-We would love to hear your feedback, so please comment at the bottom of the page!
-
 ::: sidenote
 Some readers has brought up that our suggested method is not possible with the default implementation of Box2D. We made a few modifications to Box2D to make this work: