Moved spine documentation to extension-spine

docs/en/manuals/animation.md

@@ -8,6 +8,10 @@ brief: This manual describes Defold's animation support.
 Defold has built-in support for many types of animation that you can use as a source of graphics for components:
 
 * [Flip-book animation](/manuals/flipbook-animation) - Playing a series of still images in succession
-* [Spine animation](/manuals/spine) - Playing 2D skeletal animations
 * [Model animation](/manuals/model-animation) - Playing 3D skinned animations
 * [Property animation](/manuals/property-animation) - Animate properties such as position, scale, rotation and many others
+
+Additional animation formats can be added through extensions:
+
+* [Rive animation](/extension-rive) - Playing vector based 2D skeletal animations
+* [Spine animation](/extension-spine) - Playing textured 2D skeletal animations

docs/en/manuals/components.md

@@ -23,10 +23,15 @@ Defold supports the following component types:
 * [Particle FX](/manuals/particlefx) -  Spawn particles
 * [Script](/manuals/script) - Add game logic
 * [Sound](/manuals/sound) - Play sound or music
-* [Spine model](/manuals/spinemodel) - Render a spine animation
 * [Sprite](/manuals/sprite) - Show a 2D image (with optional flipbook animation)
 * [Tilemap](/manuals/tilemap) - Show a grid of tiles
 
+Additional components can be added through extensions:
+
+* [Rive model](/extension-rive) - Render a Rive animation
+* [Spine model](/extension-spine) - Render a Spine animation
+
+
 ## Enabling and disabling components
 
 The components of a game object are enabled when the game object is created. If you wish to disable a component this is done by sending a [`disable`](/ref/go/#disable) message to the component:

docs/en/manuals/glossary.md

@@ -13,7 +13,7 @@ This glossary gives a brief description to all the things you encounter in Defol
 
 ## Atlas
 
-![Atlas](images/icons/atlas.png){.left} An atlas is a set of separate images that are compiled into a larger sheet for performance and memory reasons. They can contain still images or flip-book animated series of images. Atlases are used by GUI, Sprite, Spine model and ParticleFX components to share graphics resources. See the [Atlas documentation](/manuals/atlas) for more information.
+![Atlas](images/icons/atlas.png){.left} An atlas is a set of separate images that are compiled into a larger sheet for performance and memory reasons. They can contain still images or flip-book animated series of images. Atlases are used by a variety of components to share graphics resources. See the [Atlas documentation](/manuals/atlas) for more information.
 
 ## Builtins
 
@@ -151,14 +151,6 @@ Good performance is key in games and it is vital that you are able to do perform
 
 ![Sound](images/icons/sound.png){.left} The sound component is responsible for playing a specific sound. Currently, Defold supports sound files in the WAV and Ogg Vorbis formats. See the [Sound manual](/manuals/sound) for more information.
 
-## Spine model
-
-![Spine model](images/icons/spine-model.png){.left} The Spine model component is used to bring Spine skeletal animations to life in Defold. Read more about how to use it in the [Spine model manual](/manuals/spinemodel).
-
-## Spine scene
-
-![Spine scene](images/icons/spine-scene.png){.left} The Spine scene resource ties together the Spine JSON data file and the Defold image atlas file that is used to fill bone slots with graphics. The [Spine animation manual](/manuals/spine) contains more information.
-
 ## Sprite
 
 ![Sprite](images/icons/sprite.png){.left} A sprite is a component that extends game objects with graphics. It displays an image either from a Tile source or from an Atlas. Sprites have built-in support for flip-book and bone animation. Sprites are usually used for characters and items.
@@ -177,4 +169,4 @@ Good performance is key in games and it is vital that you are able to do perform
 
 ## Vertex shader
 
-![Vertex shader](images/icons/vertex-shader.png){.left} The vertex shader computes the screen geometry of a component's primitive polygon shapes. For any type of visual component, be it a sprite, spine model or model, the shape is represented by a set of polygon vertex positions. The vertex shader program processes each vertex (in world space) and computes the resulting coordinate that each vertex of a primitive should have. See the [Shader manual](/manuals/shader) for more information.
+![Vertex shader](images/icons/vertex-shader.png){.left} The vertex shader computes the screen geometry of a component's primitive polygon shapes. For any type of visual component, be it a sprite, tilemap or model, the shape is represented by a set of polygon vertex positions. The vertex shader program processes each vertex (in world space) and computes the resulting coordinate that each vertex of a primitive should have. See the [Shader manual](/manuals/shader) for more information.

docs/en/manuals/gui-spine.md

@@ -3,76 +3,4 @@ title: Defold GUI Spine nodes
 brief: This manual explains how to use bone animated Spine nodes in Defold GUI scenes.
 ---
 
-# GUI Spine nodes
-
-Spine animated models can be added as GUI nodes as well as game object components. This manual explains how to use imported Spine animation data in GUI scenes.
-
-## Creating a spine node
-
-First you have to import the animation data and set up a Spine Scene resource. The [Spine animation](/manuals/spine) documentation describes how to do that.
-
-Second, the contents of your Spine Scene resource must be available in your GUI scene. Add it by <kbd>right-clicking</kbd> the *Spine Scenes* section of the scene in the *Outline* and select <kbd>Add ▸ Spine Scenes...</kbd>. Choose the Spine Scenes (one or more) you wish to use in the scene.
-
-![Add Spine Scene](images/gui-spine/add.png){srcset="images/gui-spine/[email protected] 2x"}
-
-Third, create a Spine node by <kbd>right clicking</kbd> the *Nodes* section of the *Outline* and selecting <kbd>Add ▸ Spine</kbd>).
-
-![New spine node](images/gui-spine/new_node.png){srcset="images/gui-spine/[email protected] 2x"}
-
-The new node is automatically selected. Make sure to set its properties:
-
-Spine Scene
-: The Spine Scene to use as a data source for this node.
-
-Spine Default Animation
-: The animation to automatically start playing when the scene is initialized.
-
-Skin
-: The skin to use for the animation when the scene is initialized.
-
-## Runtime animation control
-
-Spine nodes can be controlled in runtime through script. To start an animation on a node, simply call the [`gui.play_spine_anim()`](/ref/gui/#gui.play_spine_anim:node-animation_id-playback-[play_properties]-[complete_function]) function:
-
-```lua
-local catnode = gui.get_node("cat_note")
-local play_properties = { blend_time = 0.3, offset = 0, playback_rate = 1 }
-gui.play_spine_anim(catnode, hash("run"), gui.PLAYBACK_ONCE_FORWARD, play_properties, function(self, node)
-    print("Animation done!")
-end)
-```
-
-Use one of the following playback modes to control animation playback:
-
-* gui.PLAYBACK_NONE
-* gui.PLAYBACK_ONCE_FORWARD
-* gui.PLAYBACK_ONCE_BACKWARD
-* gui.PLAYBACK_ONCE_PINGPONG
-* gui.PLAYBACK_LOOP_FORWARD
-* gui.PLAYBACK_LOOP_BACKWARD
-* gui.PLAYBACK_LOOP_PINGPONG
-
-## The bone hierarchy
-
-The individual bones in the Spine skeleton can be accessed as GUI nodes. The nodes are named according to their names in the Spine setup.
-
-![Spine bone names](images/gui-spine/bone.png){srcset="images/gui-spine/[email protected] 2x"}
-
-For instance, to attach another node to an existing bone node, fetch the bone node by name with [`gui.get_spine_bone()`](/ref/gui#gui.get_spine_bone) and attach the child to it:
-
-```lua
--- Attach a text node to the tail of the cat
-local cat = gui.get_node("cat_node")
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_spine_bone(cat, "tail")
-gui.set_parent(textnode, tail)
-```
-
-Bones are also accessible through [`gui.get_node()`](/ref/gui#gui.get_node), by the bone name prefixed by the name of the name of the Spine node and a slash (`/`):
-
-```lua
--- Attach a text node to the tail of the cat
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_node("cat_node/tail")
-gui.set_parent(textnode, tail)
-```
+[This manual has moved](/extension-spine).

docs/en/manuals/gui.md

@@ -88,19 +88,13 @@ Template node
 
 <div style="clear: both;"></div>
 
-Spine node
-: ![spine node](images/icons/spine-model.png){.left}
-  Displays and animates a spine model. See the [Spine node documentation](/manuals/gui-spine) for details.
-
-<div style="clear: both;"></div>
-
 ParticleFX node
 : ![particlefx node](images/icons/particlefx.png){.left}
   Plays a particle effect. See the [ParticleFX node documentation](/manuals/gui-particlefx) for details.
 
 <div style="clear: both;"></div>
 
-Add nodes by right-clicking on the *Nodes* folder and selecting <kbd>Add ▸</kbd> and then <kbd>Box</kbd>, <kbd>Text</kbd>, <kbd>Pie</kbd>, <kbd>Template</kbd>, <kbd>Spine</kbd> or <kbd>ParticleFx</kbd>.
+Add nodes by right-clicking on the *Nodes* folder and selecting <kbd>Add ▸</kbd> and then <kbd>Box</kbd>, <kbd>Text</kbd>, <kbd>Pie</kbd>, <kbd>Template</kbd> or <kbd>ParticleFx</kbd>.
 
 ![Add nodes](images/gui/add_node.png){srcset="images/gui/[email protected] 2x"}
 
@@ -152,15 +146,6 @@ Pie Fill Angle (pie nodes)
 Template (template nodes)
 : The GUI scene file to use as template for the node. See the [Template node documentation](/manuals/gui-template) for details.
 
-Spine Scene (spine nodes)
-: The Spine Scene to use for this node. See the [Spine node documentation](/manuals/gui-spine) for details.
-
-Default Animation (spine nodes)
-: The animation to automatically play on this node. See the [Spine node documentation](/manuals/gui-spine) for details.
-
-Skin (spine nodes)
-: The skin to use for the node. See the [Spine node documentation](/manuals/gui-spine) for details.
-
 ParticleFX (particlefx nodes)
 : The particle effect to use on this node. See the [ParticleFX node documentation](/manuals/gui-particlefx) for details.
 
@@ -227,7 +212,7 @@ Adjust Mode
 
   If the GUI scene property *Adjust Reference* is set to `Disabled`, this setting will be ignored.
 
-Clipping Mode (box, pie and spine nodes)
+Clipping Mode (box and pie nodes)
 : Sets the clipping mode on the node:
 
   - `None` renders the node as usual.
@@ -235,10 +220,10 @@ Clipping Mode (box, pie and spine nodes)
 
   See the [GUI clipping manual](/manuals/gui-clipping) for details.
 
-Clipping Visible (box, pie and spine nodes)
+Clipping Visible (box and pie nodes)
 : Set to render the node's content in the stencil area. See the [GUI clipping manual](/manuals/gui-clipping) for details.
 
-Clipping Inverted (box, pie and spine nodes)
+Clipping Inverted (box and pie nodes)
 : Invert the stencil mask. See the [GUI clipping manual](/manuals/gui-clipping) for details.
 
 

docs/en/manuals/importing-assets.md

@@ -25,7 +25,6 @@ When the assets are imported into Defold they can be used by the various compone
 
 * Images can be used to create many kinds of visual components frequently used in 2D games. Read more about [how to import and use 2D graphics here](/manuals/importing-graphics).
 * Sounds can be used by the [Sound component](/manuals/sound) to play sounds.
-* Spine animation data is used by the [Spine component](/manuals/spinemodel) to show and animate Spine models.
 * Fonts are used by the [Label component](/manuals/label) and by [text nodes](/manuals/gui-text) in a GUI.
 * Collada models can be used by the [Model component](/manuals/model) to show 3D models with animations. Read more about [how to import and use 3D models here](/manuals/importing-models).
 

docs/en/manuals/importing-graphics.md

@@ -5,7 +5,7 @@ brief: This manual covers how to import and use 2D graphics.
 
 # Importing 2D graphics
 
-Defold supports many kinds of visual components frequently used in 2D games. You can use Defold to create static and animated sprites, UI components, particle effects, tile maps, bitmap fonts and Spine animations. Before you can create any of these visual components you need to import image files with the graphics that you wish to use. To import image files you simply drag the files from the file system on your computer and drop them in an appropriate place in the Defold editor *Assets pane*.
+Defold supports many kinds of visual components frequently used in 2D games. You can use Defold to create static and animated sprites, UI components, particle effects, tile maps and bitmap fonts. Before you can create any of these visual components you need to import image files with the graphics that you wish to use. To import image files you simply drag the files from the file system on your computer and drop them in an appropriate place in the Defold editor *Assets pane*.
 
 ![Importing files](images/graphics/import.png){srcset="images/graphics/[email protected] 2x"}
 
@@ -70,14 +70,4 @@ Learn more about particle effects in the [Particle fx manual](/manuals/particlef
 
   ![gui](images/graphics/gui.png){srcset="images/graphics/[email protected] 2x"}
 
-Learn more about GUIs in the [GUI manual](/manuals/gui).
-
-![spine](images/icons/spine-model.png){.icon} Spine model
-: Spine models gets their data from Spine scene resources. Those contain two pieces of data:
-
-  1. A Spine Json file that describes the bone animations.
-  2. An atlas that contain the images that are attached to the bones. Spine models cannot use data from tile maps.
-
-  ![spine](images/graphics/spine.png){srcset="images/graphics/[email protected] 2x"}
-
-Learn more about Spine models in the [Spine model manual](/manuals/spinemodel).
+Learn more about GUIs in the [GUI manual](/manuals/gui).

docs/en/manuals/model-animation.md

@@ -5,7 +5,7 @@ brief: This manual describes how to use 3D model animations in Defold.
 
 # 3D skinned animation
 
-Skeletal animation of 3D models is similar to [Spine animation](/manuals/spine-animation) but works in 3D as opposed to 2D. The 3D model is not cut into separate parts and tied to a bone like in cutout animation. Instead, the bones apply deformation to vertices in the model and you have great control over how much a bone should affect the vertices.
+Skeletal animation of 3D models use the bones of the model to apply deformation to vertices in the model.
 
 For details on how to import 3D data into a Model for animation, see the [Model documentation](/manuals/model).
 

docs/en/manuals/properties.md

@@ -82,15 +82,6 @@ Legacy functions for reading and writing game object properties also exist. They
 | *linear_damping* | Linear damping of the collision object. | `vector3` | `get+set`{.mark} |
 | *angular_damping* | Angular damping of the collision object. | `vector3` | `get+set`{.mark} |
 
-*SPINE MODEL COMPONENT PROPERTIES*
-
-| property   | description                            | type            |                  |
-| ---------- | -------------------------------------- | --------------- | ---------------- |
-| *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} |
-| *playback_rate* | The playback rate of the animation. A multiplier to the animation playback rate. | `number` | `get+set`{.mark} |
-
 *MODEL (3D) COMPONENT PROPERTIES*
 
 | property   | description                            | type            |                  |

docs/en/manuals/shader.md

@@ -49,7 +49,6 @@ Attributes
 : A value associated with an individual vertex. Attributes are passed to the shader by the engine and if you want to access an attribute you just declare it in your shader program. Different component types have a different set of attributes:
   - Sprite has `position` and `texcoord0`.
   - Tilegrid has `position` and `texcoord0`.
-  - Spine model has `position` and `texcoord0`.
   - GUI node has `position`, `textcoord0` and `color`.
   - ParticleFX has `position`, `texcoord0` and `color`.
   - Model has `position`, `texcoord0` and `normal`.

docs/en/manuals/spine.md

@@ -3,241 +3,4 @@ title: Spine bone animation in Defold
 brief: This manual explains how to bring Spine animations from _Spine_ or _Dragon Bone_ into Defold.
 ---
 
-# Spine animation
-
-_Spine_ is a third party animation tool by Esoteric Software. Spine animation provides 2D _skeletal animation_ support (see http://en.wikipedia.org/wiki/Skeletal_animation). This is a fundamentally different technique from [flipbook animations](/manuals/flipbook-animation) that is closer to cutout animation. In cutout animation separate pieces of the animated object (e.g body parts, eyes, mouth etc) are moved individually between each frame. Spine animation let you build an invisible, virtual skeleton consisting of a hierarchy of interconnected _bones_. This skeleton, or _rig_, is then animated and individual images are attached to the bones. Defold supports animations created or exported in the [Spine JSON format](http://esotericsoftware.com/spine-json-format). Skeletal animation is very smooth since the engine can interpolate the location of each bone for each frame. It is particularly useful to animate characters and animals, but works very well for other types of objects, like ropes, vehicles or foliage.
-
-  ![Spine animation](images/animation/spine_animation.png){.inline}
-  ![Run loop](images/animation/frog_runloop.gif){.inline}
-
-Defold implements runtime evaluation and animation expressed in the [Spine JSON format](http://esotericsoftware.com/spine-json-format).
-
-Defold supports most of Spine's animation features, including inverse kinematics (IK).
-
-::: important
-Currently, Defold does not support animation keys that flip bones over the X or Y axis. Defold supports mesh animation but only with bones, meaning that you can't animate single vertices. If you need to animate single vertices you can do that through a bone being 100% bound to that vertex only and animate the bone.
-:::
-
-::: important
-The Spine runtime implementation in Defold supports all Spine 2.x features. The runtime provides only limited additional support for Spine 3.x features. Make sure to use only Spine 2.x features to ensure compatibility with the Defold runtime!
-:::
-
-## Concepts
-
-*Spine JSON data file*
-: This data file contains the skeleton, all the image slot names, skins and the actual animation data. No images are embedded in this file though. Create this file from your animation software of choice.
-
-*Spine scene*
-: The Defold resource tying together the Spine JSON data file and the Defold image atlas file that is used to fill bone slots with graphics.
-
-*Spine model*
-: The _SpineModel_ component is put in a game object to bring the graphics and animation to the screen. The component contains the skeleton game object hierarchy, which animation to play, what skin to use and it also specifies the material used for rendering the model. See [SpineModel documentation](/manuals/spinemodel) for details.
-
-*Spine Node*
-: If using Spine animation in a GUI scene, use Spine GUI nodes instead of Spine model components. See the [GUI spine documentation](/manuals/gui-spine) for details.
-
-## Animation tools
-
-The Spine JSON data format that Defold supports can be created by Esoteric Software's _Spine_ software. In addition, _Dragon Bones_ has the ability to export Spine JSON data files.
-
-_Spine_ is available from http://esotericsoftware.com
-
-![Spine](images/spine/spine.png)
-
-_Dragon Bones_ is available from http://dragonbones.com
-
-![Dragon Bones](images/spine/dragonbones.png)
-
-::: important
-_Dragon Bones_ should typically be able to export to Spine JSON data files without any problems. If your _Dragon Bones_ exported data file isn't rendered properly in Defold we recommend that you use the official [Spine Skeleton Viewer](http://esotericsoftware.com/spine-skeleton-viewer) to first verify that the data can be correctly parsed. If there is a problem with the exported data the Spine Skeleton Viewer can pinpoint problems in the JSON data file, for instance missing or incorrect fields.
-:::
-
-
-## Importing a Spine character and animations
-
-When you have a model and animations that you have created in Spine, the process of importing them into Defold is straightforward:
-
-- Export a Spine JSON version of the animation data.
-- Put the exported JSON file somewhere in your project hierarchy.
-- Put all images associated with the model somewhere in your project hierarchy.
-- Create an _Atlas_ file and add all the images to it. (See [2D graphics documentation](/manuals/2dgraphics) for details on how to create an atlas and below for some caveats)
-
-![Export JSON from Spine](images/spine/spine_json_export.png)
-
-If you work in _Dragon Bones_, simply select *Spine* as your output data type. Also select *Images* as image type. This will export a *.json* file and all necessary images into a folder. Then add those to Defold as described above.
-
-![Export JSON from Dragon Bones](images/spine/dragonbones_json_export.png)
-
-When you have the animation data and image files imported and set up in Defold, you need to create a _Spine scene_ resource file:
-
-- Create a new _Spine scene_ resource file (Select <kbd>New ▸ Spine Scene File</kbd> from the main menu)
-- The new file opens in the spine scene editor.
-- Set the *Properties*.
-
-![Setup the Spine Scene](images/spine/spinescene.png){srcset="images/spine/[email protected] 2x"}
-
-Spine Json
-: The Spine JSON file to use as source for bone and animation data.
-
-Atlas
-: The atlas containing images named corresponding to the Spine data file.
-
-## Creating SpineModel components
-
-When you have all data imported and your _Spine scene_ resource file ready, you can create SpineModel components. See [SpineModel documentation](/manuals/spinemodel) for details.
-
-## Creating Spine GUI nodes
-
-You can also use Spine animations in GUI scenes. See the [GUI spine documentation](/manuals/gui-spine) for details.
-
-## Playing animations
-
-To run animations on your model, simply call the [`spine.play_anim()`](/ref/spine#spine.play_anim) function:
-
-```lua
-function init(self)
-    -- Play the "walk" animation on component "spinemodel" and blend against previous
-    -- animation for the first 0.1 seconds
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "run", go.PLAYBACK_LOOP_FORWARD, anim_props)
-end
-```
-
-![Spine model in game](images/animation/spine_ingame.png){srcset="images/animation/[email protected] 2x"}
-
-If an animation is played with any of the `go.PLAYBACK_ONCE_*` modes and you have provided a callback function to `spine.play_anim()` the callback is run on animation complete. See below for information on callbacks.
-
-### Cursor animation
-
-In addition to using the `spine.play_anim()` to advance a spine animation, *Spine Model* components expose a "cursor" property that can be manipulated with `go.animate()` (more about [property animations](/manuals/property-animation)):
-
-```lua
--- Set the animation on the spine model but don't run it.
-spine.play_anim("#spinemodel", "run_right", go.PLAYBACK_NONE)
-
--- Set the cursor to position 0
-go.set("#spinemodel", "cursor", 0)
-
--- Tween the cursor slowly between 0 and 1 pingpong with in-out quad easing.
-go.animate("#spinemodel", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_INOUTQUAD, 6)
-```
-
-::: important
-When tweening or setting the cursor, timeline events may not fire as expected.
-:::
-
-### The bone hierarchy
-
-The individual bones in the Spine skeleton are represented internally as game objects. In the *Outline* view of the Spine model component, the full hierarchy is visible. You can see each bone's name and its place in the skeleton hierarchy.
-
-![Spine model hierarchy](images/animation/spine_bones.png){srcset="images/animation/[email protected] 2x"}
-
-With the bone name at hand, you are able to retrieve the instance id of the bone in runtime. The function [`spine.get_go()`](/ref/spine#spine.get_go) returns the id of the specified bone and you can, for instance, child other game objects under the animated game object:
-
-```lua
--- Attach pistol game object to the hand of the heroine
-local hand = spine.get_go("heroine#spinemodel", "front_hand")
-msg.post("pistol", "set_parent", { parent_id = hand })
-```
-
-### Timeline events
-
-Spine animations can trigger timed events by sending messages at precise moments. They are very useful for events that should take place in sync with your animation, like playing footstep sounds, spawning particle effects, attaching or detaching objects to the bone hierarchy or anything else you would like to happen.
-
-Events are added in the Spine software and are visualized on the playback timeline:
-
-![Spine events](images/animation/spine_events.png)
-
-Each event is referenced with a name identifier ("bump" in the example above) and each event instance on the timeline can contain additional information:
-
-Integer
-: A numerical value expressed as an integer.
-
-Float
-: A floating point numerical value.
-
-String
-: A string value.
-
-When the animation plays and events are encountered, `spine_event` messages are sent back to the script component that called `spine.play()`. The message data contains the custom numbers and strings embedded in the event, as well as a few additional fields that are sometimes useful:
-
-`t`
-: The number of seconds passed since the first frame of the animation.
-
-`animation_id`
-: The animation name, hashed.
-
-`string`
-: The provided string value, hashed.
-
-`float`
-: The provided floating point numerical value.
-
-`integer`
-: The provided integer numerical value.
-
-`event_id`
-: The event identifier, hashed.
-
-`blend_weight`
-: How much of the animation is blended in at this point. 0 means that nothing of the current animation is part of the blend yet, 1 means that the blend consists of the current animation to 100%.
-
-```lua
--- Spine animation contains events that are used to play sounds in sync with the animation.
--- These arrive here as messages.
-function on_message(self, message_id, message, sender)
-  if message_id == hash("spine_event") and message.event_id == hash("play_sound") then
-    -- Play animation sound. The custom event data contains the sound component and the gain.
-    local url = msg.url("sounds")
-    url.fragment = message.string
-    sound.play(url, { gain = message.float })
-  end
-end
-```
-
-## Completion callbacks
-
-The spine animation function `spine.play_anim()` support 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 `spine.cancel()`. The callback can be used to trigger events on animation completion or to chain multiple animations together.
-
-```lua
-local function anim_done(self)
-    -- the animation is done, do something useful...
-end
-
-function init(self)
-    -- Play the "walk" animation on component "spinemodel" and blend against previous
-    -- animation for the first 0.1 seconds, then call callback.
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "run", go.PLAYBACK_LOOP_FORWARD, anim_props, anim_done)
-end
-```
-
-## Playback Modes
-
-Animations can be played either once or in a loop. How the animation plays is determined by the playback mode:
-
-* go.PLAYBACK_NONE
-* go.PLAYBACK_ONCE_FORWARD
-* go.PLAYBACK_ONCE_BACKWARD
-* go.PLAYBACK_ONCE_PINGPONG
-* go.PLAYBACK_LOOP_FORWARD
-* go.PLAYBACK_LOOP_BACKWARD
-* go.PLAYBACK_LOOP_PINGPONG
-
-The pingpong modes run the animation first forward, then backward.
-
-## Atlas caveats
-
-The animation data references the images used for the bones by name with the file suffix stripped off. You add images to your Spine project in the Spine software and they are listed in the hierarchy under *Images*:
-
-![Spine images hierarchy](images/spine/spine_images.png)
-
-This example shows files laid out in a flat structure. It is, however, possible to organize the files in subfolders and the file references will reflect that. For instance, a file *head_parts/eyes.png* on disk will be referenced as *head_parts/eyes* when you use it in a slot. This is also the name used in the exported JSON file so when creating the Defold image atlas, all names must match an atlas animation.
-
-If you select <kbd>Add Images</kbd> Defold will automatically create animation groups with the same name as the added files, but with the file suffix stripped off. So, after having added the file *eyes.png* its animation group can be referenced by the name "eyes". This works with file names only, not paths.
-
-So what do you do if your animation references "head_parts/eyes"? The easiest way to accomplish a match is to add an animation group (right click the root node in the Atlas *Outline* view and select *Add Animation Group*). You can then name that group "head_parts/eyes" (it's just a name, not a path and `/` characters are legal) and then add the file "eyes.png" to the group.
-
-![Atlas path names](images/spine/atlas_names.png){srcset="images/spine/[email protected] 2x"}
-
-Moving on to animate your Spine model, please read the [Animation documentation](/manuals/animation).
+[This manual has moved](/extension-spine)

docs/en/manuals/spinemodel.md

@@ -3,78 +3,4 @@ title: Spine model components in Defold
 brief: This manual explains how to create SpineModel components in Defold.
 ---
 
-# Spine Model
-
-The SpineModel component is used to bring _Spine_ skeletal animations to life in Defold.
-
-## Creating Spine model components
-
-Select a game object to hold the new component:
-
-Either create the component in-place (<kbd>right click</kbd> the game object and select <kbd>Add Component ▸ Spine Model</kbd>)
-
-Or create it on file first (<kbd>right click</kbd> a location in the *Assets* browser, then select <kbd>New... ▸ Spine Model</kbd> from the context menu), then add the file to the game object by <kbd>right clicking</kbd> the game object and selecting <kbd>Add Component File</kbd>).
-
-## Spine model properties
-
-Apart from the properties *Id*, *Position* and *Rotation* the following component specific properties exist:
-
-*Spine scene*
-: Set this to the Spine scene file you created earlier.
-
-*Blend Mode*
-: If you want a blend mode other than the default `Alpha`, change this property.
-
-*Material*
-: If you need to render the model with a custom material, change this property.
-
-*Default animation*
-: Set this to the animation you want the model to start with.
-
-*Skin*
-: If your model has skins, select the one you want it to start with.
-
-You should now be able to view your Spine model in the editor:
-
-![Spine model in editor](images/spinemodel/spinemodel.png){srcset="images/spinemodel/[email protected] 2x"}
-
-### Blend modes
-:[blend-modes](../shared/blend-modes.md)
-
-## Runtime manipulation
-
-You can manipulate spine models in runtime through a number of different functions and properties (refer to the [API docs for usage](/ref/spine/)).
-
-### Runtime animation
-
-Defold provides powerful support for controlling animation in runtime. Refer to the [spine animation manual](/manuals/spine) to learn more.
-
-### Changing properties
-
-A spine model also has a number of different properties that can be manipulated using `go.get()` and `go.set()`:
-
-`animation`
-: The current model animation (`hash`) (READ ONLY). You change animation using `spine.play_anim()` (see the [spine animation manual](/manuals/spine)).
-
-`cursor`
-: The normalized animation cursor (`number`).
-
-`material`
-: The spine model material (`hash`). You can change this using a material resource property and `go.set()`. Refer to the [API reference for an example](/ref/spine/#material).
-
-`playback_rate`
-: The animation playback rate (`number`).
-
-`skin`
-: The current skin on the component (`hash`).
-
-## Material constants
-
-{% include shared/material-constants.md component='spine' variable='tint' %}
-
-`tint`
-: The color tint of the spine model (`vector4`). The vector4 is used to represent the tint with x, y, z, and w corresponding to the red, green, blue and alpha tint.
-
-## Project configuration
-
-The *game.project* file has a few [project settings](/manuals/project-settings#spine) related to spine models.
+[This manual has moved](/extension-spine)

docs/gr/manuals/animation.md

@@ -19,16 +19,6 @@ brief: Αυτό το εγχειρίδιο περιγράφει την υποστ
   ![Animation sheet](images/animation/animsheet.png){.inline}
   ![Run loop](images/animation/runloop.gif){.inline}
 
-## Κινούμενη εικόνα της σπονδυλικής στήλης Spine
-
-Το Spine animation παρέχει υποστήριξη 2D _skeletal animation_ (βλ. Http://en.wikipedia.org/wiki/Skeletal_animation). Αυτή είναι μια θεμελιωδώς διαφορετική τεχνική που είναι πιο κοντά στο κινούμενο σχέδιο. Στην κινούμενη κίνηση, ξεχωριστά κομμάτια του κινούμενου αντικειμένου (π.χ. μέρη σώματος, μάτια, στόμα κ.λπ.) μετακινούνται ξεχωριστά μεταξύ κάθε καρέ. Το Spine animation σάς επιτρέπει να δημιουργήσετε έναν αόρατο, εικονικό σκελετό που αποτελείται από μια ιεραρχία διασυνδεδεμένων _bones_. Αυτός ο σκελετός, ή _rig_, στη συνέχεια κινείται και μεμονωμένες εικόνες προσαρτώνται στα οστά. Το Defold υποστηρίζει κινούμενα σχέδια που δημιουργούνται ή εξάγονται στη μορφή [Spine JSON format](http://esotericsoftware.com/spine-json-format). Το σκελετικό κινούμενο σχέδιο είναι πολύ ομαλό καθώς η μηχανή μπορεί να παρεμβάλει τη θέση κάθε οστού για κάθε πλαίσιο.
-
-  Για λεπτομέρειες σχετικά με τον τρόπο εισαγωγής δεδομένων Spine σε μοντέλο Spine για κινούμενα σχέδια, ανατρέξτε στην [Spine documentation](/manuals/spine).
-
-
-  ![Spine animation](images/animation/spine_animation.png){.inline}
-  ![Run loop](images/animation/frog_runloop.gif){.inline}
-
 ## 3D κινούμενα γραφικά
 
 Το σκελετικό animation των τρισδιάστατων μοντέλων είναι παρόμοιο με το Spine animation, αλλά λειτουργεί σε 3D σε αντίθεση με το 2D. Το τρισδιάστατο μοντέλο δεν είναι κομμένο σε ξεχωριστά μέρη και δεμένο σε κόκαλο, όπως σε κινούμενα σχέδια. Αντ 'αυτού, τα οστά εφαρμόζουν παραμόρφωση στις κορυφές του μοντέλου και έχετε μεγάλο έλεγχο του πόσο ένα οστό πρέπει να επηρεάζει τις κορυφές.
@@ -123,115 +113,6 @@ end
 
 Μπορεί να παρέχεται μια προαιρετική συνάρτηση που καλείται μετά την ολοκλήρωση. Θα κληθεί σε κινούμενα σχέδια που αναπαράγονται σε οποιαδήποτε από τις λειτουργίες `ONCE_*`.
 
-## Spine model animation
-
-Για να εκτελέσετε κινούμενες εικόνες στο μοντέλο σας, απλώς καλέστε το [`spine.play_anim()`](/ref/spine#spine.play_anim) function:
-
-```lua
-local function anim_done(self)
-    -- the animation is done, do something useful...
-end
-
-function init(self)
-    -- Play the "walk" animation on component "spinemodel" and blend against previous
-    -- animation for the first 0.1 seconds, then call callback.
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "run", go.PLAYBACK_LOOP_FORWARD, anim_props, anim_done)
-end
-```
-
-![Spine model in game](images/animation/spine_ingame.png){srcset="images/animation/[email protected] 2x"}
-
-Εάν ένα κινούμενο σχέδιο αναπαράγεται με οποιαδήποτε από τις λειτουργίες `go.PLAYBACK_ONCE_*` και έχετε δώσει μια λειτουργία επανάκλησης στο `spine.play_anim()` η επιστροφή κλήσης εκτελείται σε κινούμενη εικόνα ολοκληρωμένη. Δείτε παρακάτω για πληροφορίες σχετικά με τις επιστροφές κλήσεων.
-
-### Μοντέλο σπονδυλικής στήλης - Κινούμενα σχέδια δρομέα - Spine model - Cursor animation
-
-Εκτός από τη χρήση του `spine.play_anim()` για να προωθήσετε μια κινούμενη εικόνα της σπονδυλικής στήλης, τα στοιχεία, *Spine Model* εκθέτουν μια ιδιότητα "δρομέα" που μπορεί να χειριστεί με το `go.animate()`:
-
-```lua
--- Set the animation on the spine model but don't run it.
-spine.play_anim("#spinemodel", "run_right", go.PLAYBACK_NONE)
-
--- Set the cursor to position 0
-go.set("#spinemodel", "cursor", 0)
-
--- Tween the cursor slowly between 0 and 1 pingpong with in-out quad easing.
-go.animate("#spinemodel", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_INOUTQUAD, 6)
-```
-
-::: σημαντικό
-Όταν κάνετε tweening ή ρυθμίζετε τον κέρσορα, τα συμβάντα timeline ενδέχεται να μην ενεργοποιούνται όπως αναμένεται.
-:::
-
-### Μοντέλο σπονδυλικής στήλης - Η ιεραρχία των οστών - Spine model - The bone hierarchy
-
-Τα μεμονωμένα οστά στο σκελετό της Σπονδυλικής στήλης παρουσιάζονται εσωτερικά ως αντικείμενα παιχνιδιού. Στην προβολή *Outline* του συστατικού μοντέλου Spine, είναι ορατή η πλήρης ιεραρχία. Μπορείτε να δείτε το όνομα κάθε οστού και τη θέση του στην ιεραρχία του σκελετού.
-
-![Spine model hierarchy](images/animation/spine_bones.png){srcset="images/animation/[email protected] 2x"}
-
-Με το όνομα των οστών στο χέρι, μπορείτε να ανακτήσετε το αναγνωριστικό εμφάνισης του οστού στο χρόνο εκτέλεσης. Η λειτουργία [`spine.get_go()`](/ref/spine#spine.get_go) επιστρέφει το αναγνωριστικό του καθορισμένου οστού και μπορείτε, για παράδειγμα, να θυμάστε άλλα αντικείμενα παιχνιδιού κάτω από το κινούμενο αντικείμενο παιχνιδιού:
-
-```lua
--- Attach pistol game object to the hand of the heroine
-local hand = spine.get_go("heroine#spinemodel", "front_hand")
-msg.post("pistol", "set_parent", { parent_id = hand })
-```
-
-### Μοντέλο σπονδυλικής στήλης - Συμβάντα Χρονοδιαγράμματος Spine model - Timeline events
-
-Τα κινούμενα σχέδια της σπονδυλικής στήλης μπορούν να πυροδοτήσουν χρονικά συμβάντα στέλνοντας μηνύματα σε συγκεκριμένες στιγμές. Είναι πολύ χρήσιμα για εκδηλώσεις που θα πρέπει να πραγματοποιούνται σε συγχρονισμό με την κινούμενη εικόνα σας, όπως αναπαραγωγή ήχων βήματος, αναπαραγωγή εφέ σωματιδίων, σύνδεση ή απόσπαση αντικειμένων στην ιεραρχία των οστών ή οτιδήποτε άλλο θέλετε να συμβεί.
-
-Τα συμβάντα προστίθενται στο λογισμικό Spine και απεικονίζονται στο playback timeline:
-
-![Spine events](images/animation/spine_events.png)
-
-Κάθε συμβάν αναφέρεται με ένα αναγνωριστικό ονόματος ("bump" στο παραπάνω παράδειγμα) και κάθε παρουσία συμβάντος στο χρονοδιάγραμμα μπορεί να περιέχει πρόσθετες πληροφορίες:
-
-Integer
-: Μια αριθμητική τιμή που εκφράζεται ως ακέραιος.
-
-Float
-: Μια αριθμητική τιμή κινητής υποδιαστολής.
-
-String
-: Μια τιμή συμβολοσειράς.
-
-Όταν συναντώνται τα κινούμενα σχέδια και τα συμβάντα, τα μηνύματα `spine_event` αποστέλλονται πίσω στο στοιχείο δέσμης ενεργειών που ονομάζεται` spine.play () ". Τα δεδομένα μηνυμάτων περιέχουν τους προσαρμοσμένους αριθμούς και συμβολοσειρές που είναι ενσωματωμένες στο συμβάν, καθώς και μερικά επιπλέον πεδία που μερικές φορές είναι χρήσιμα:
-
-`t`
-: Ο αριθμός των δευτερολέπτων που πέρασαν από το πρώτο καρέ της κινούμενης εικόνας.
-
-`animation_id`
-: Το όνομα κινούμενης εικόνας, κατακερματισμένο.
-
-`string`
-: Η παρεχόμενη τιμή συμβολοσειράς, κατακερματισμένη.
-
-`float`
-: Η παρεχόμενη αριθμητική τιμή κυμαινόμενου σημείου.
-
-`integer`
-: Η παρεχόμενη ακέραια αριθμητική τιμή.
-
-`event_id`
-: Το αναγνωριστικό συμβάντος, κατακερματισμένο.
-
-`blend_weight`
-: Πόσο από τα κινούμενα σχέδια αναμιγνύεται σε αυτό το σημείο. 0 σημαίνει ότι τίποτα από το τρέχον κινούμενο σχέδιο δεν είναι ακόμη μέρος του μίγματος, 1 σημαίνει ότι το μείγμα αποτελείται από την τρέχουσα κινούμενη εικόνα έως 100%.
-
-```lua
--- Spine animation contains events that are used to play sounds in sync with the animation.
--- These arrive here as messages.
-function on_message(self, message_id, message, sender)
-  if message_id == hash("spine_event") and message.event_id == hash("play_sound") then
-    -- Play animation sound. The custom event data contains the sound component and the gain.
-    local url = msg.url("sounds")
-    url.fragment = message.string
-    sound.play(url, { gain = message.float })
-  end
-end
-```
-
 ## 3D μοντέλο κινουμένων σχεδίων
 
 Τα μοντέλα είναι κινούμενα με το [`model.play_anim()`](/ref/model#model.play_anim) function:
@@ -468,7 +349,7 @@ go.animate("go", "position.y", go.PLAYBACK_LOOP_PINGPONG, 200, square_easing, 2.
 
 ## Επιστροφές κλήσεων ολοκλήρωσης - Completion callbacks
 
-Όλες οι συναρτήσεις κινούμενης εικόνας (`go.animate()`, `gui.animate()`, `gui.play_flipbook()`, `gui.play_spine_anim()`, `sprite.play_flipbook()`, `spine.play_anim()` και `model.play_anim()`)  υποστηρίζουν μια προαιρετική λειτουργία επανάκλησης Lua ως το τελευταίο όρισμα. Αυτή η λειτουργία θα κληθεί όταν το κινούμενο σχέδιο έχει παιχτεί μέχρι το τέλος. Η λειτουργία δεν απαιτείται ποτέ για βρόχους κινούμενων εικόνων, ούτε όταν μια κινούμενη εικόνα ακυρώνεται χειροκίνητα μέσω του `go.cancel_animations()`. Η επιστροφή κλήσης μπορεί να χρησιμοποιηθεί για την ενεργοποίηση συμβάντων κατά την ολοκλήρωση των κινούμενων σχεδίων ή για την αλυσίδα πολλαπλών κινούμενων σχεδίων μαζί.
+Όλες οι συναρτήσεις κινούμενης εικόνας (`go.animate()`, `gui.animate()`, `gui.play_flipbook()`, `sprite.play_flipbook()` και `model.play_anim()`)  υποστηρίζουν μια προαιρετική λειτουργία επανάκλησης Lua ως το τελευταίο όρισμα. Αυτή η λειτουργία θα κληθεί όταν το κινούμενο σχέδιο έχει παιχτεί μέχρι το τέλος. Η λειτουργία δεν απαιτείται ποτέ για βρόχους κινούμενων εικόνων, ούτε όταν μια κινούμενη εικόνα ακυρώνεται χειροκίνητα μέσω του `go.cancel_animations()`. Η επιστροφή κλήσης μπορεί να χρησιμοποιηθεί για την ενεργοποίηση συμβάντων κατά την ολοκλήρωση των κινούμενων σχεδίων ή για την αλυσίδα πολλαπλών κινούμενων σχεδίων μαζί.
 
 
 Η ακριβής υπογραφή λειτουργίας της επιστροφής κλήσης διαφέρει ελαφρώς μεταξύ των λειτουργιών κινούμενης εικόνας. Δείτε την τεκμηρίωση API για τη λειτουργία που χρησιμοποιείτε.

docs/ko/manuals/animation.md

@@ -10,13 +10,6 @@ Defold는 오브젝트 컴포넌트의 그래픽 소스로 사용할 수 있는
 
 ![](images/animation/animsheet.png) ![](images/animation/runloop.gif)
 
-#### Spine animation
-스파인 애니메이션은 2D 스켈레톤 애니메이션을 제공합니다 (http://en.wikipedia.org/wiki/Skeletal_animation 참고). 이는 컷아웃 애니메이션과는 근본적으로 다른 기술입니다.  컷아웃 애니메이션에서는 애니메이션 오브젝트의 개별 조각들(예를 들어 몸체, 눈, 입 등)이 각 프레임간 개별적으로 움직입니다. 스파인 애니메이션은 서로 연결된 뼈대 구조로 구성된 보이지 않는 가상의 골격을 만듭니다. 개별 이미지를 각 뼈대에 붙이고 이 골격(skeleton) 혹은 릭(rig)을 애니메이션 처리 할 수 있습니다. Defold는 [스파인 JSON 포멧](http://ko.esotericsoftware.com/spine-json-format)으로 애니메이션을 생성하거나 익스포트 하는 것을 지원합니다. 스켈레톤 애니메이션은 엔진이 매 프레임마다 각 뼈대의 위치를 보간(interpolate)해 주기 때문에 매우 부드럽게 움직입니다.
-
-스파인 데이터를 어떻게 임포트 하는지 자세히 보려면 [Spine](/manuals/spine) 문서를 참고 바랍니다.
-
-![](images/animation/spine_animation.png) ![](images/animation/frog_runloop.gif)
-
 #### 3D skinned animation
 3D 모델의 스켈레톤 애니메이션은 스파인 애니메이션과 비슷하지만 2D가 아니라 3D로 동작합니다. 3D 모델은 별도의 파트로 잘리지 않고 컷아웃 애니메이션 처럼 뼈대로 묶입니다. 대신 이 뼈대들은 모델의 버텍스(vertex)에 변형(deformation)을 적용할 수 있으며, 뼈대가 버텍스에 영향을 미치는 정도를 제어할 수 있습니다.
 
@@ -98,100 +91,6 @@ end
 
 완료시 호출되는 선택적(optional) 함수가 제공될 수 있습니다(위 예제의 flipbook_done 함수처럼). 이는 ONCE__* 모드에서 재생되는 애니메이션으로부터 호출됩니다.
 
-## Animating Spine models
-스파인 모델에 애니메이션을 적용하려면, 간단히 spine.play_anim() 함수를 호출하면 됩니다:
-
-```lua
-local function anim_done(self)
-    -- 애니메이션이 종료되고, 뭔가 유용한 일을 합니다...
-end
-
-function init(self)
-    -- "spinemodel" 컴포넌트의 "walk" 애니메이션을 플레이하고 첫 0.1초 동안 이전 애니메이션과 블랜딩한 후 콜백을 호출합니다.
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "walk", go.PLAYBACK_LOOP_FORWARD, anim_props, anim_done)
-end
-```
-
-![Spine model in game](images/animation/spine_model_ingame.png)
-
-애니메이션이 **go.PLAYBACK_ONCE_** 모드로 플레이되고 spine.play_anim() 함수에 콜백 함수를 넘기면 애니메이션 완료시 이 콜백 함수가 실행됩니다. 아래의 콜백(callback) 정보를 참고바랍니다.
-
-### Cursor animation
-spine.play_anim() 를 사용해서 스파인 애니메이션을 진행하는 것 외에도, **Spine Model** 컴포넌트는 go.animate() 으로 다룰 수 있는 "cursor" 속성을 제공합니다.
-
-```lua
--- 스파인 모델에 애니메이션을 설정하고 재생은 안함
-spine.play_anim("#spinemodel", "run_right", go.PLAYBACK_NONE)
-
--- 커서 위치를 0으로 설정함
-go.set("#spinemodel", "cursor", 0)
-
--- 커서를 느리게 트위닝 시키고 in-out quad 이징(easing) 효과를 주고 핑퐁 애니메이션 처리함
-go.animate("#spinemodel", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_INOUTQUAD, 6)
-```
-
-> 커서가 트위닝(tween)되거나 셋팅되면, 타임라인 이벤트(timeline events)가 예상대로 발생하지 않을 수 있습니다.
-
-### The bone hierarchy
-스파인 스켈레톤의 개별 뼈대들은 게임 오브젝트에 내부적으로 나타납니다. 스파인 모델 컴포넌트의 아웃라인 창(**Outline**)에서 전체 계층구조가 표시됩니다. 여기서 스켈레톤 구조의 각 뼈대의 이름과 위치를 볼 수 있습니다.
-
-![Spine model hierarchy](images/animation/spine_model_hierarchy.png)
-
-뼈대의 이름을  사용하여, 런타임시 뼈대의 인스턴스 아이디를 검색할 수 있습니다. spine.get_go() 함수는 특정 뼈대의 아이디를 반환합니다. 예를 들어, 움직이는 게임 오브젝트 아래에 다른 오브젝트를 자식 객체로 넣을 수 있습니다:
-
-```lua
--- heroine의 손에 권총 오브젝트를 갖다 붙임
-local hand = spine.get_go("heroine#spinemodel", "front_hand")
-msg.post("pistol", "set_parent", { parent_id = hand })
-```
-
-### Timeline events
-스파인 애니메이션은 정확한 순간에 메세지를 보내서 이벤트를 트리거 할 수 있습니다. 이는 발자국 소리를 재생하거나, 파티클 효과를 스폰하거나, 뼈대 계층구조에 오브젝트를 붙이고 떼거나 하는 등등의 이벤트를 애니메이션과 동기화 되어 배치 해야만 하는 경우에 매우 유용합니다.
-
-이벤트들은 스파인 소프트웨어에서 추가할 수 있으며 플레이백 타임라인(playback timeline)에서 시각화 됩니다:
-
-![Spine events](images/animation/spine_events.png)
-
-각 이벤트는 이름 식별자(name identifier: 위 예제에서 "bump")로 참조되며 타임라인의 각 이벤트 인스턴스는 추가 정보를 포함할 수 있습니다:
-
-#### Integer
-정수형 숫자값
-#### Float
-부동소수점 숫자값
-#### String
-문자열 값
-
-애니메이션이 플레이되고 타임라인 이벤트가 발생하면, spine_event 메세지가 spine.play()를 호출했던 스크립트 컴포넌트로 전송됩니다. 이 메세지 데이터에는 이벤트에 내장된 커스텀 숫자나 문자열 뿐만 아니라 때로는 유용한 추가적인 필드도 포함하고 있습니다:
-
-#### t
-애니메이션의 첫 번째 프레임 이후 경과된 시간(초)
-#### animation_id
-애니메이션 이름, 해쉬(hash)됨
-#### string
-제공된 문자열 값, 해쉬(hash)됨
-#### float
-제공된 부동 소수점 숫자값
-#### integer
-제공된 정수형 숫자값
-#### event_id
-이벤트 식별자, 해쉬(hash)됨
-#### blend_weight
-애니메이션이 얼마나 블렌드(blend) 되었는지에 대한 값. 0은 현재 애니메이션이 아직 블렌드의 일부분이 아님을 의미하며, 1은 현재 애니메이션이 100%로 구성된 블렌드 라는것을 의미함.
-
-```lua
--- 스파인 애니메이션이 애니메이션과 동기화된 사운드를 플레이하기 위해 이벤트를 포함하고 있음.
--- 여기로 메세지가 도착함.
-function on_message(self, message_id, message, sender)
-  if message_id == hash("spine_event") and message.event_id == hash("play_sound") then
-    -- 애니메이션 사운드 플레이하기. 커스텀 이벤트 데이터에 사운드 컴포넌트 이름과 출력값(gain)이 들어 있음
-    local url = msg.url("sounds")
-    url.fragment = message.string
-    sound.play(url, { gain = message.float })
-  end
-end
-```
-
 ## 3D Model animation
 모델은 model.play_anim() 함수를 사용해서 애니메이션 됩니다:
 
@@ -315,7 +214,7 @@ go.animate("go", "position.y", go.PLAYBACK_LOOP_PINGPONG, 100, square_easing, 2.
 ```
 
 ## Completion callbacks
-모든 애니메이션 함수(go.animate(), gui.animate(), gui.play_flipbook(), gui.play_spine_anim(), spine.play_anim(), model.play_anim())는 마지막 인자값으로 선택적인 Lua 콜백 함수(optional Lua callback function)를 지원합니다. 이 함수는 애니메이션의 재생이 종료되면 호출됩니다. 이 함수는 루프 애니메이션일 경우이거나 애니메이션이 go.cancel_animations()로 수동적으로 취소 되었을 경우엔 호출되지 않습니다. 콜백은 애니메이션 완료시 이벤트를 트리거하거나 여러 애니메이션을 함께 연결하는데 사용됩니다.
+모든 애니메이션 함수(go.animate(), gui.animate(), gui.play_flipbook(), model.play_anim())는 마지막 인자값으로 선택적인 Lua 콜백 함수(optional Lua callback function)를 지원합니다. 이 함수는 애니메이션의 재생이 종료되면 호출됩니다. 이 함수는 루프 애니메이션일 경우이거나 애니메이션이 go.cancel_animations()로 수동적으로 취소 되었을 경우엔 호출되지 않습니다. 콜백은 애니메이션 완료시 이벤트를 트리거하거나 여러 애니메이션을 함께 연결하는데 사용됩니다.
 
 콜백의 정확한 함수 형태(signature)는 애니메이션 함수마다 조금씩 다릅니다. 자세한 것은 API 문서를 참고 바랍니다.
 

docs/ko/manuals/gui-spine.md

@@ -1,62 +0,0 @@
----
-title: Defold manual
----
-
-# GUI Spine nodes
-게임 오브젝트에서 뿐만 아니라 GUI 애니메이션에서도 스파인 본 애니메이션을 사용할 수 있습니다. 이 매뉴얼은 GUI 씬에서 스파인 애니메이션 데이터를 임포트하는 방법을 설명합니다.
-
-> 현재, 스파인 노드는 스파인 이벤트를 지원하지 않습니다. **SpineModel** 게임 오브젝트는 애니메이션 타임라인의 이벤트를 포함하고 게임오브젝트에 메세지를 전송할 수 있지만 스파인 노드에서는 지원되지 않습니다.
-
-임포트된 스파인 본 애니메이션(Spine bone animation)은 게임 오브젝트 뿐 아니라 GUI 씬에서도 사용할 수 있습니다(**SpineModel** 컴포넌트를 통해서). Defold에서 스파인 본 애니메이션을 동작시키기 위해, 먼저 애니메이션 데이터를 임포트하고 스파인 씬(Spine Scene) 리소스를 설정해야 합니다. 이를 위한 설명은 [Spine animation](/manuals/spine) 문서를 참고하시기 바랍니다.
-
-GUI 씬에서 스파인 씬 리소스의 컨텐츠를 사용하려면, **Outline** 창의 **Spine Scenes** 폴더에 마우스 오른쪽 버튼을 눌려 **Add Spine Scene** 메뉴를 선택하고 사용하려는 스파인 씬을 선택합니다.
-
-![Add Spine Scene](images/gui/gui_spine_add_scene.png)
-
-![Added Spine Scene](images/gui/gui_spine_added_scene.png)
-
-이제 스파인 노드를 만들면(**Outline** 창의 **Nodes** 폴더에 마우스 오른쪽 버튼 누르고 **Add Spine Node** 선택) 그에 따른 새 스파인 노드의 프로퍼티들을 설정할 수 있습니다.
-
-![Spine node](images/gui/gui_spine_node.png)
-
-#### Spine Scene
-이 노드의 데이터 소스로 사용할 스파인 씬
-#### Spine Default Animation
-씬이 초기화 될 때 자동적으로 재생할 애니메이션
-#### Skin
-씬이 초기화 될 때 애니메이션에 사용할 스킨
-
-## Runtime animation control
-스파인 노드는 스크립트를 통해 런타임시 제어할 수 있습니다. 노드에서 애니메이션을 시작하려면 [gui.play_spine()](http://www.defold.com/ref/gui/#gui.play_spine) 함수를 호출하기만 하면 됩니다.
-
-```lua
-local catnode = gui.get_node("cat_note")
-local blend_time = 0.3
-gui.play_spine(catnode, hash("run"), gui.PLAYBACK_ONCE_FORWARD, blend_time, function(self, node)
-    print("Animation done!")
-end)
-```
-
-## The bone hierarchy
-스파인 스켈레톤에서 뼈 각각은 GUI 노드로 존재하게 됩니다. 이 노드들은 스파인 설정에서 지정된 이름에 따라 지어집니다.
-
-![Spine bone names](images/gui/gui_spine_bones.png)
-
-예를 들어, 어떤 노드를 다른 본 노드에 연결하려면, [gui.get_spine_bone()](http://www.defold.com/ref/gui/#gui.get_spine_bone) 를 사용하여 하위의 본 노드를 이름으로 조회해서 자식 노드로 연결할 수 있습니다.
-
-```lua
--- text 노드를 cat의 tail에 연결함
-local cat = gui.get_node("cat_node")
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_spine_bone(cat, "tail")
-gui.set_parent(textnode, tail)
-```
-
-또한 모든 본은 스파인 노드의 이름과 "/"를 접두어로 사용하여 go.get_node() 로 접근 가능합니다.
-
-```lua
--- text 노드를 cat의 tail에 연결함
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_node("cat_node/tail")
-gui.set_parent(textnode, tail)
-```

docs/ko/manuals/spine.md

@@ -1,83 +0,0 @@
----
-title: Defold manual
----
-
-# Spine animation
-이 매뉴얼은 스파인(Spine)이나 드래곤 본(Dragon Bone)으로부터 Defold로 스파인 애니메이션을 불러오는 방법을 설명합니다.
-
-## Spine
-스파인은 Esoteric Software에서 개발한 서드파티 애니메이션 툴이며, 골격 릭(skeletal rig)의 움직임을 조절하여 오브젝트의 다양한 부분을 움직이는 애니메이션을 만들 수 있습니다. 이는 캐릭터나 동물을 애니메이션 하는데 특히 유용하지만 밧줄, 자동차, 나뭇잎 같은 다른 오브젝트에도 잘 적용할 수 있습니다.
-
-Defold는 런타임 평가(runtime evaluation) 및 스파인 JSON 포멧으로 된 애니메이션을 구현합니다.
-
-Defold는 역기구학(IK = inverse kinematic)을 포함한 스파인 애니메이션 기능 대부분을 지원합니다.
-
-> 현재, Defold는 X 혹은 Y축(axis)을 기준으로 뼈대를 뒤집는 애니메이션 키(animation keys)를 지원하지 않습니다. Defolds는 메쉬(mesh) 애니메이션을 지원하지만 오직 뼈대만 사용하므로 단일 버텍스를 애니메이션 할 수 없습니다. 만약 단일 버텍스(single vertices) 애니메이션이 필요하다면 뼈대를 통해 버텍스에만 100% 연결(bind)하고 뼈대를 애니메이션 해야 합니다.
-
-## Concepts
-
-#### Spine JSON data file
-이 데이터 파일은 스켈레톤, 모든 이미지 슬롯의 이름, 스킨, 실제 애니메이션 데이터를 포함하고 있으며 이미지가 포함되어 있지 않습니다. 당신이 선택한 애니메이션 소프트웨어에서 이 파일을 만들어보세요.
-#### Spine scene
-Defold 리소스는 스파인 JSON 데이터 파일과 뼈대 슬롯(bone slots)을 그래픽으로 채우는데 사용되는 이미지 아틀라스를 함께 연결합니다.
-#### Spine model
-스파인 모델 컴포넌트는 그래픽 및 애니메이션을 화면에 표시하기 위해 게임 오브젝트에 넣어야 합니다. 이 컴포넌트는 애니메이션을 재생하고, 사용할 스킨과 모델을 렌더링 하기 위해 사용되는 메터리얼을 지정하는 스켈레톤 게임 오브젝트 계층구조(skeleton game object hierarchy)를 포함하고 있습니다. 자세한 내용은 [Spine Model](/manuals/spinemodel) 문서를 참고 바랍니다.
-
-#### Spine Node
-GUI씬에서 스파인 애니메이션을 사용하는 경우, 스파인 모델 컴포넌트 대신 스파인 GUI 노드를 사용하세요. 자세한 것은 [GUI Spine](/manuals/gui-spine) 문서를 참고 바랍니다.
-
-## Animation tools
-Defold가 지원하는 스파인 JSON 데이터 포멧은 Esoteric Software의 스파인 소프트웨어로 만들 수 있습니다. 게다가, 드래곤 본스(Dragon Bones) 또한 스파인 JSON 데이터 파일로 익스포트 할 수 있습니다.
-
-스파인은 http://esotericsoftware.com 에서 사용 가능합니다.
-
-![Spine](images/spine/spine.png)
-
-드래곤 본스는 http://dragonbones.com 에서 사용 가능합니다.
-
-![Dragon Bones](images/spine/dragonbones.png)
-
-## Importing a Spine character and animations
-스파인에서 제작한 애니메이션과 모델이 있다면, Defold로 임포트하는 과정은 간단합니다:
-
-1. 스파인 JSON 버전으로 애니메이션 데이터를 익스포트함
-2. 익스포트된 JSON 파일을 프로젝트 아무데나 복사함
-3. 모델과 관련된 모든 이미지를 프로젝트 아무데나 복사함
-4. 아틀라스 파일을 만들어 이미지들을 추가함 (아틀라스를 만드는 방법은 [2D graphics](/manuals/2dgraphics) 문서를 참고)
-
-![Export JSON from Spine](images/spine/spine_json_export.png)
-
-드래곤 본즈(Dragon Bones)에서 작업하는 경우, 간단하게 Export Data Type을 **Spine**으로 하면 됩니다. 또한 Image Type으로는 **Images**를 선택하세요. 이렇게 하면 **.json** 파일과 필수적인 모든 이미지가 폴더로 익스포트됩니다. 그리고 나서 위의 설명대로 Defold에 추가하면 됩니다.
-
-![Export JSON from Dragon Bones](images/spine/dragonbones_json_export.png)
-
-Defold에서 에니메이션 데이터와 이미지 파일을 임포트하고 셋업한 경우, 스파인 씬 파일(Spine scene file)을 생성해야 합니다:
-
-1. 새로운 스파인 씬 파일을 생성함 (메인 메뉴에서 **New > Spine Scene File** 선택)
-2. 스파인 씬 파일에서 **spine_json** 과 **atlas** 속성을 설정해서 임포트된 JSON 파일과 새로 생성한 아틀라스 파일을 참조함
-
-![Setup the Spine Scene](images/spine/spine_spinescene.png)
-
-## Creating SpineModel components
-모든 데이터를 임포트하고 스파인 씬 파일을 준비하면, 스파인 모델을 만들 수 있습니다. 자세한 것은  [SpineModel](/manuals/spinemodel) 문서를 참고 바랍니다.
-
-## Creating Spine GUI nodes
-또한 GUI씬에서 스파인 애니메이션을 사용할 수도 있습니다. 자세한 것은 [GUI spine](/manuals/gui-spine) 문서를 참고 바랍니다.
-
-## Animating Spine models and nodes
-Defold는 Lua 인터페이스를 통해 애니메이션을 재생하는 방법에 대한 강력한 런타임 제어 기능을 제공합니다. 자세한 것은 [Animation](/manuals/animation) 문서를 참고 바랍니다.
-
-## Atlas caveats
-애니메이션 데이터는 뼈대에 사용된 이미지를 파일 접미사(suffix)가 생략된 이름으로 참조합니다. 스파인 소프트웨어에서 스파인 프로젝트로 이미지를 추가 하면 **Images** 아래의 계층에 리스트업 됩니다:
-
-![Spine images hierarchy](images/spine/spine_images.png)
-
-이 예제는 평평한 구조(flat structure)로 배치된 파일을 보여줍니다. 하지만 하위 폴더로 파일들을 정리할 수 있으며 이 파일들의 참조가 반영됩니다. 예를 들어, 디스크의 "head_parts/eyes.png" 파일을 슬롯에 사용하면 "head_parts/eyes"로 참조됩니다. 또한 이 이름은 JSON 파일로 익스포트 되어도 사용되므로, Defold 이미지 아틀라스를 생성할 때 모든 이름을 아틀라스 애니메이션과 일치시켜야 합니다.
-
-**Add Images**를 선택하면 Defold는 추가된 파일과 같은 이름을 사용하는 애니메이션 그룹(animation group)을 자동적으로 생성하지만  파일명의 접미사(suffix)는 생략됩니다. 그러므로 애니메이션 그룹에 "eyes.png" 파일을 추가한 후엔 "eyes"라는 이름으로 참조됩니다. 이는 경로가 아니라 오직 파일 이름으로만 동작합니다.
-
-그렇다면 애니메이션이 "head_parts/eyes"를 참조하고 있다면 어떻게 해야 할까요? 이름을 일치시키기 위한 가장 쉬운 방법은 애니메이션 그룹을 추가(아웃라인 창(**Outline**)의 Atlas 루트 노드에 마우스 오른쪽 클릭 후 **Add Animation Group** 선택)하는 것 입니다. 그리고 애니메이션 그룹의 이름을 "head_parts/eyes"로 바꾸고(경로가 아니고 / 문자가 들어간 이름일 뿐) 이 그룹에 "eyes.png"파일을 추가하면 됩니다.
-
-![Atlas path names](images/spine/spine_atlas_names.png)
-
-스파인 모델(Spine model)을 애니메이션으로 움직이게 하려면  [Animation](/manuals/animation) 문서를 참고 바랍니다.

docs/pl/manuals/importing-assets.md

@@ -25,7 +25,6 @@ Kiedy zasoby są już zaimportowane do projektu, mogą być wykorzystywane przez
 
 * Pliki graficzne mogą być używane w różnego rodzaju komponentach wizualnych, często używanych np. w grach 2D. Więcej szczegółów znajdziesz w [tej instrukcji jak importować i używać grafiki 2D](/manuals/importing-graphics).
 * Pliki dźwiękowe mogą być używane przez [komponent dźwięku](/manuals/sound) w celu odtwarzania dźwięków.
-* Pliki animacji szkieletowej (Spine) mogą być używane przez [komponent Spine](/manuals/spinemodel) w celu wyświetlania i animowania modeli Spine.
 * Pliki fontów mogą być używane przez [komponent etykiety](/manuals/label) i przez [węzły tekstowe](/manuals/gui-text) w GUI.
 * Pliki modeli Collada mogą być używane przez [komponent modeli trójwymiarowych](/manuals/model) w celu wyświetlania i animowania modeli trójwymiarowych. Więcej szczegółów znajdziesz w [tej instrukcji jak importować i używać grafiki 3D](/manuals/importing-models). 
 

docs/ru/manuals/animation.md

@@ -8,6 +8,5 @@ brief: Данное руководство описывает работу с а
 Defold имеет встроенную поддержку нескольких типов анимации, которые можно использовать в качестве источника графики для компонентов:
 
 * [Мултикадровая анимация](/manuals/flipbook-animation) --- Последовательное воспроизведение серии статичных изображений
-* [Spine-анимация](/manuals/spine) --- Проигрывание скелетных 2D-анимаций
 * [Модельная анимация](/manuals/model-animation) --- Проигрывание анимации 3D-моделей
 * [Анимация свойств](/manuals/property-animation) --- Анимация свойств, таких как положение, масштаб, углы поворота и многих других

docs/ru/manuals/gui-spine.md

@@ -1,78 +0,0 @@
----
-title: GUI-нода Spine
-brief: Это руководство объясняет, как использовать ноды Spine со скелетной анимацией в GUI сценах Defold.
----
-
-# GUI-нода Spine
-
-Анимированные Spine-модели можно добавлять в качестве GUI-нод, а также в качестве компонентов игровых объектов. В этом руководстве объясняется, как использовать импортированные данные Spine-анимации в GUI-сценах.
-
-## Создание ноды Spine
-
-Во-первых, необходимо импортировать данные анимации и настроить ресурс Spine Scene.. О том, как это сделать, описано в [руководстве по Spine-анимации](/manuals/spine).
-
-Во-вторых, содержимое ресурса Spine Scene должно быть доступно в GUI-сцене. Добавьте его, <kbd>кликнув ПКМ</kbd> в секции *Spine Scenes* сцены в *Outline* и выберите <kbd>Add ▸ Spine Scenes...</kbd>. Выберите Spine Scenes (одну или несколько), которые вы хотите использовать в сцене
-
-![Add Spine Scene](images/gui-spine/add.png){srcset="images/gui-spine/[email protected] 2x"}
-
-В-третьих, создайте ноду Spine, <kbd>кликнув ПКМ</kbd> на секции *Nodes* в *Outline* и выбрав <kbd>Add ▸ Spine</kbd>.
-
-![New spine node](images/gui-spine/new_node.png){srcset="images/gui-spine/[email protected] 2x"}
-
-Новая нода будет выделена автоматически. Убедитесь, что заданы ее свойства:
-
-Spine Scene
-: Spine Scene, которую следует использовать в качестве источника данных для данной ноды.
-
-Spine Default Animation
-: Анимация, которая автоматически начнет воспроизводиться при инициализации сцены.
-
-Skin
-: Скин, который будет использоваться для анимации при инициализации сцены.
-
-## Управление анимацией в рантайме
-
-Нодами Spine можно управлять в рантайме посредством скрипта. Чтобы запустить анимацию в ноде, достаточно вызвать функцию [`gui.play_spine_anim()`](/ref/gui/#gui.play_spine_anim:node-animation_id-playback-[play_properties]-[complete_function]):
-
-```lua
-local catnode = gui.get_node("cat_note")
-local play_properties = { blend_time = 0.3, offset = 0, playback_rate = 1 }
-gui.play_spine_anim(catnode, hash("run"), gui.PLAYBACK_ONCE_FORWARD, play_properties, function(self, node)
-    print("Animation done!")
-end)
-```
-
-Используйте один из следующих режимов воспроизведения анимации:
-
-* gui.PLAYBACK_NONE
-* gui.PLAYBACK_ONCE_FORWARD
-* gui.PLAYBACK_ONCE_BACKWARD
-* gui.PLAYBACK_ONCE_PINGPONG
-* gui.PLAYBACK_LOOP_FORWARD
-* gui.PLAYBACK_LOOP_BACKWARD
-* gui.PLAYBACK_LOOP_PINGPONG
-
-## Скелетная иерархия
-
-Доступ к отдельным костям в скелете Spine можно получить в виде GUI-нод. Ноды именуются в соответствии с их именами в настройках Spine.
-
-![Spine bone names](images/gui-spine/bone.png){srcset="images/gui-spine/[email protected] 2x"}
-
-Например, чтобы присоединить другую ноду к существующей ноде кости, найдите ноду кости по имени с помощью [`gui.get_spine_bone()`](/ref/gui#gui.get_spine_bone) и присоедините к ней дочернюю ноду:
-
-```lua
--- Attach a text node to the tail of the cat
-local cat = gui.get_node("cat_node")
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_spine_bone(cat, "tail")
-gui.set_parent(textnode, tail)
-```
-
-Кости также доступны через [`gui.get_node()`](/ref/gui#gui.get_node), по имени кости с префиксом имени ноды Spine и слэшем (`/`):
-
-```lua
--- Прикрепить ноду Text к хвосту кошки
-local textnode = gui.new_text_node(vmath.vector3(400, 0, 0), "Hello tail!")
-local tail = gui.get_node("cat_node/tail")
-gui.set_parent(textnode, tail)
-```

docs/ru/manuals/importing-assets.md

@@ -25,7 +25,6 @@ Defold поддерживает изображения в форматах PNG
 
 * Изображения используются для создания многих видов визуальных компонентов, часто применяемых в 2D-играх. Подробнее о том, как импортировать и использовать 2D-графику [читайте здесь](/manuals/importing-graphics).
 * Звуковые файлы используются [компонентом Sound](/manuals/sound) для воспроизведения аудио контента.
-* Данные Spine-анимации используются [компонентами Spine](/manuals/spinemodel) для отображения и анимирования Spine-моделей.
 * Шрифты используются [компонентом Label](/manuals/label) и [и текстовыми нодами](/manuals/gui-text) в GUI.
 * Модели в формате Collada могут использоваться [компонентом Model](/manuals/model) для отображения 3D моделей с анимацией. См. [как импортировать и использовать 3D модели](/manuals/importing-models).
 

docs/ru/manuals/spine.md

@@ -1,243 +0,0 @@
----
-title: Скелетная Spine-анимация
-brief: Данное руководство объясняет как перенести скелетную Spine-анимацию из _Spine_ или _Dragon Bone_ в Defold.
----
-
-# Скелетная Spine-анимация
-
-_Spine_ --- это сторонний пакет анимации от компании Esoteric Software. Spine-анимация предоставляет поддержку двумерной скелетной анимации (см. [Скелетная анимация](https://ru.wikipedia.org/wiki/Скелетная_анимация)). Данная техника близка к перекладной анимации, при этом она в корне отличается от [мультикадровой](/manuals/flipbook-animation). В перекладной анимации отдельные части анимируемого объекта (то есть части тела, глаза, рот и т.д.) движутся независимо между кадрами. Spine-анимация позволяет выстраивать невидимые, виртуальные скелеты, состоящие из иерархии взаимосвязанных _костей_. Такой скелет, или по-другому _риг_, далее анимируется и отдельные изображения прикрепляются к его костям. Defold поддерживает анимацию созданную либо экспортированную в [Spine JSON-формате](http://esotericsoftware.com/spine-json-format). Скелетная анимация получается очень плавной поскольку движок интерполирует положение каждой кости для каждого кадра. На практике это весьма удобно для анимирования персонажей и животных, но также отлично работает и для других типов объектов, например, веревок, машин или растительности.
-
-  ![Spine animation](images/animation/spine_animation.png){.inline}
-  ![Run loop](images/animation/frog_runloop.gif){.inline}
-
-Defold реализует во время выполнения игры вычисление и анимацию выраженную в [Spine JSON-формате](http://esotericsoftware.com/spine-json-format).
-
-Defold поддерживает большинство возможностей Spine-анимации, включая инверсную кинематику (IK).
-
-::: important
-На данный момент, Defold не поддерживает ключи анимации, которые переворачивают кости относительно осей X или Y. Defold поддерживает Mesh-анимацию, но только с костями, имеется в виду, что нельзя анимировать отдельные вершины. Если нужно анимировать отдельные вершины, можно сделать это посредством кости, которая на 100% привязана к данной вершине, анимируя эту кость.
-:::
-
-::: important
-Среда выполнения Spine реализованная в Defold поддерживает все возможности Spine версий 2.x. Среда выполнения предоставляет лишь ограниченную поддержку возможностей из Spine 3.x. Старайтесь задействовать только возможности из Spine 2.x, чтобы быть уверенными в совместимости со средой выполнения в Defold!
-:::
-
-## Концепции
-
-*Spine JSON файл данных*
-: Данный файл содержит скелет, все имена слотов изображений, скины и всю актуальную информацию об анимации. В этот файл не встраиваются никакие изображения. Создается такой файл подходящим приложением для анимации.
-
-*Spine-сцена*
-: Ресурс Defold, связывающий вместе Spine JSON файл данных и файл атласа с изображениями, которые используются под заполнение графикой слотов костей.
-
-*Spine-модель*
-: Компонент _Spine Model_ вставляется в игровой объект, чтобы вывести графику и анимацию на экран. Компонент содержит скелетную иерархию игрового объекта, информацию о том, которую из анимаций воспроизводить, какой применять скин, а также он задает материал, который будет задействован для рендеринга модели. За подробностями обращайтесь к [руководству по Spine Model](/manuals/spinemodel).
-
-*Spine-Нода*
-: В случае использования Spine-анимации в GUI-сцене, используйте Spine GUI-ноды вместо компонентов Spine Model. За подробностями обращайтесь к [руководству по GUI spine](/manuals/gui-spine).
-
-## Инструменты анимации
-
-Spine JSON файл данных поддерживаемый Defold может быть создан в ПО компании Esoteric Software _Spine_. Как вариант, _Dragon Bones_ умеет экспортировать в Spine JSON файл данных.
-
-_Spine_ доступен здесь: http://esotericsoftware.com 
-
-![Spine](images/spine/spine.png)
-
-_Dragon Bones_ доступен здесь: http://dragonbones.com 
-
-![Dragon Bones](images/spine/dragonbones.png)
-
-::: important
-Обычно экспорт в Spine JSON файл данных в пакете _Dragon Bones_ работает без каких-либо проблем. Если Spine JSON файлов данных экспортированный из _Dragon Bones_ не рендерится должным образом в Defold, мы рекомендуем использовать официальное ПО [Spine Skeleton Viewer](http://esotericsoftware.com/spine-skeleton-viewer), чтобы сначала проверить, что данные парсятся корректно. Если возникает проблема с экспортированными данными на этом этапе, Spine Skeleton Viewer может подсветить проблемы в JSON файле данных, например, указав на недостающие или некорректные поля.
-:::
-
-
-## Импортирование Spine-персонажа и анимации
-
-Когда имеется модель и анимация, которые вы создали в Spine, процесс их импорта в Defold достаточно прост:
-
-- Экспортируйте Spine JSON версию данных анимации.
-- Расположите экспортированный JSON файл где-нибудь в иерархии вашего проекта.
-- Добавьте все изображения связанные с моделью где-нибудь в иерархии вашего проекта.
-- Создайте файл _Atlas_ и добавьте туда все изображения. (См. [руководство по 2D графике](/manuals/2dgraphics) чтобы лучше понять, как создаются атласы, а также см. предостережения ниже).
-
-![Export JSON from Spine](images/spine/spine_json_export.png)
-
-Если вы работаете в _Dragon Bones_, просто выберите *Spine* в качестве выходного типа данных. Также выберете *Images* как тип изображения. Таким образом, экспортируется *.json* файл и все необходимые изображения в одну папку. Добавьте далее содержимое этой папки в Defold как в шагах выше.
-
-![Export JSON from Dragon Bones](images/spine/dragonbones_json_export.png)
-
-Когда есть данные анимации и файлы изображений импортированные и установленные в Defold, вам необходимо создать файл-ресурс _Spine scene_:
-
-- Создайте файл-ресурс _Spine scene_ (Выберите <kbd>New ▸ Spine Scene File</kbd> из главного меню)
-- Новый файл откроется в редакторе Spine-сцены.
-- Установите *Свойства*.
-
-![Setup the Spine Scene](images/spine/spinescene.png){srcset="images/spine/[email protected] 2x"}
-
-Spine Json
-: Spine JSON файл, который будет использоваться как источник данных анимации и костей
-
-Atlas
-: Атлас, содержащий изображения, именованные в соответствии со Spine-файлом данных.
-
-## Создание компонентов Spine Model
-
-Когда есть все нужные импортированные данные и ресурс-файл _Spine Scene_ готов, можно создать компонент Spine Model. За подробностями обращайтесь к [руководству по Spine Model](/manuals/spinemodel).
-
-## Создание Spine GUI-нод
-
-Также можно использовать Spine-анимацию в GUI-сценах. За подробностями обращайтесь к [руководству по GUI spine](/manuals/gui-spine).
-
-## Воспроизведение анимации
-
-Для запуска анимации модели, просто вызовите функцию [`spine.play_anim()`](/ref/spine#spine.play_anim):
-
-```lua
-function init(self)
-    -- Проиграть анимацию "walk" для компонента "spinemodel"
-    -- и смешать ее относительно предыдущей анимации первые 0.1 секунд
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "run", go.PLAYBACK_LOOP_FORWARD, anim_props)
-end
-```
-
-![Spine model in game](images/animation/spine_ingame.png){srcset="images/animation/[email protected] 2x"}
-
-Если анимация воспроизводится с каким-либо режимом вида `go.PLAYBACK_ONCE_*` и вы предоставили функцию обратного вызова в метод `spine.play_anim()`, функция сработает по окончании анимации. См. ниже информацию о функциях обратного вызова.
-
-### Анимация курсора
-
-В дополнении к использованию метода `spine.play_anim()` для более продвинутой анимации модели компоненты типа *Spine Model* предоставляют свойство "cursor", которым можно управлять с помощью вызова `go.animate()` (подробнее в [руководстве по анимации свойств](/manuals/property-animation)):
-
-```lua
--- Установить анимацию для Spine модели, но не проигрывать ее.
-spine.play_anim("#spinemodel", "run_right", go.PLAYBACK_NONE)
-
--- Выставить курсор в 0
-go.set("#spinemodel", "cursor", 0)
-
--- Сделать медленный твининг курсора между 0 и 1 в режиме Loop Ping Pong со смягчением InOutQuad
-go.animate("#spinemodel", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_INOUTQUAD, 6)
-```
-
-::: important
-При анимировании или установке позиции курсора, события временной шкалы могут срабатывать не так, как ожидается.
-:::
-
-### Иерархия костей
-
-Отдельные кости в Spine-скелете представлены в виде игровых объектов. В представлении *Outline* компонента Spine Model, видна вся иерархия. Вы можете видеть имя каждой кости и ее место в иерархии скелета.
-
-![Spine model hierarchy](images/animation/spine_bones.png){srcset="images/animation/[email protected] 2x"}
-
-Зная имя кости, можно получить идентификатор экземпляра кости во время выполнения игры. Функция [`spine.get_go()`](/ref/spine#spine.get_go) возвращает идентификатор заданной кости и вы можете, например, сделать другие игровые объекты дочерними для данного анимируемого игрового объекта:
-
-```lua
--- Прикрепить игровой объект пистолета к руке героини
-local hand = spine.get_go("heroine#spinemodel", "front_hand")
-msg.post("pistol", "set_parent", { parent_id = hand })
-```
-
-### События таймлайна
-
-Spine-анимация может активировать временные события, посылая сообщения в определенные моменты. Они весьма удобны для событиый, которые должны произойти синхронно с вашей анимацией, например, проигрывание звука шагов, испускание эффектов частиц, присоединение или отсоединение объектов от иерархии костей или что-либо еще, что вы хотели бы выполнить.
-
-События добавляются в программе Spine и визуализируются на таймлайне воспроизведения:
-
-![Spine events](images/animation/spine_events.png)
-
-Каждое событие имеет ссылку с именем идентификатора (в примере выше --- "bump"") и каждый экземпляр события на таймлайне может содержать дополнительную информацию:
-
-Integer
-: Числовое значение, выраженное типом integer.
-
-Float
-: Числовое значение с плавающей точкой.
-
-String
-: Строковое значение.
-
-Когда анимация воспроизводится и наступают события, сообщение `spine_event` посылаются обратно в тот скрипт, что вызвал `spine.play`. Данные сообщения содержат пользовательские числа и строки, встроенные в это событие, а также несколько дополнительных полей, которые также могут быть полезны:
-
-`t`
-: Количество секунд, прошедших после первого кадра анимации.
-
-`animation_id`
-: Имя анимации в хэшированном виде.
-
-`string`
-: Переданное строковое значение, в хэшированном виде.
-
-`float`
-: Переданное числовое значение с плавающей точкой.
-
-`integer`
-: Предоставленное целочисленное значение.
-
-`event_id`
-: Идентификатор события, в хэшированном виде.
-
-`blend_weight`
-: Указывает, какой процент от анимации будет использован в бленде в текущий момент времени. 0 означает, что ничего из текущей анимации не является частью бленда, 1 означает, что бленд состоит из текущей анимации на 100%.
-
-```lua
--- Spine-анимация содержит события, которые используются для проигрывания звуков синхронно с анимацией.
--- Эти события прибывают сюда в виде сообщений
-function on_message(self, message_id, message, sender)
-  if message_id == hash("spine_event") and message.event_id == hash("play_sound") then
-    -- Проиграть звук анимации. Пользовательские данные события содержат компонент звука и уровень усиления
-    local url = msg.url("sounds")
-    url.fragment = message.string
-    sound.play(url, { gain = message.float })
-  end
-end
-```
-
-## Завершающие функции обратного вызова
-
-Функция Spine-анимации `spine.play_anim()` поддерживают опциональные функции обратного вызова в качестве последнего переданного аргумента. Такие переданные функции будут вызваны когда анимация проиграется до конца. Функции никогда не будут вызваны для зацикленных анимаций, а также для анимаций, которые были отменены вручную вызовом `spine.cancel()`.  Функция обратного вызова может быть использована для активации других событий по завершению анимации или для склеивания нескольких анимаций в одну цепочку.
-
-```lua
-local function anim_done(self)
-    -- анимация проиграна, сделаем что-нибудь полезное...
-end
-
-function init(self)
-        -- Проиграть анимацию "walk" для компонента "spinemodel" и смешать ее относительно предыдущей
-        -- анимация для первых 0.1 секунды, затем вызвать функцию обратного вызова
-    local anim_props = { blend_duration = 0.1 }
-    spine.play_anim("#spinemodel", "run", go.PLAYBACK_LOOP_FORWARD, anim_props, anim_done)
-end
-```
-
-## Режимы воспроизведения
-
-Анимация может быть воспроизведена либо однократно либо зациклено. Как именно это происходит, определяется режимом воспроизведения:
-
-* go.PLAYBACK_NONE
-* go.PLAYBACK_ONCE_FORWARD
-* go.PLAYBACK_ONCE_BACKWARD
-* go.PLAYBACK_ONCE_PINGPONG
-* go.PLAYBACK_LOOP_FORWARD
-* go.PLAYBACK_LOOP_BACKWARD
-* go.PLAYBACK_LOOP_PINGPONG
-
-Режим Ping Pong проигрывает анимацию сначала вперед, затем в обратном порядке.
-
-## Предостережения по поводу атласов
-
-Данные анимации ссылаются на изображения, задействованные для костей, по имени с убранным суффиксом расширения файла. Вы добавляете изображения в Spine проект в программе Spine и они выстраиваются в иерархию в блоке *Images*:
-
-![Spine images hierarchy](images/spine/spine_images.png)
-
-Данный пример показывает расположение файлов в плоской структуре. Однако, возможно организовать файлы в подпапки и ссылки на файлы отразят такую структуру. Например, на файл *head_parts/eyes.png* на диске будет иметься ссылка как *head_parts/eyes* при использовании этого изображение для слота. Также, это имя будет использовано и в экспортированном JSON файле, поэтому для создаваемого атласа изображений в Defold, все имена должны совмещаться с анимациями атласа.
-
-При выборе <kbd>Add Images</kbd> Defold автоматически создаст группы анимаций с тем же именем как и добавленные файлы, но с вырезанным суффиксом расширения файла. Поэтому, после добавленного файла *eyes.png* его анимационная группа может быть доступна по ссылке с именем "eyes". Это работает только для имен файлов, но не путей.
-
-Так что следует сделать, если анимация имеет ссылку "head_parts/eyes"? Легкий способ добиться совпадения --- это добавить анимационную группу (правый клик по корневой ноде в области Atlas *Outline* и далее следует выбрать *Add Animation Group*). Затем можно называть группу "head_parts/eyes" (это просто имя, а не путь, так что символы `/` вполне допустимы) и затем добавить файл "eyes.png" в эту группу.
-
-![Atlas path names](images/spine/atlas_names.png){srcset="images/spine/[email protected] 2x"}
-
-Приступая к анимации Spine-модели, обращайтесь к [руководству по анимации](/manuals/animation).

docs/ru/manuals/spinemodel.md

@@ -1,80 +0,0 @@
----
-title: Компонент Spine Model
-brief: Это руководство объясняет процесс создания компонентов Spine Model в Defold.
----
-
-# Компонент Spine Model
-
-Компонент Spine Model используется для оживления скелетной _Spine_-анимации.
-
-## Создание Spine-модели
-
-Выделите игровой объект для размещения в нем нового компонента:
-
-- Либо создайте компонент на месте (<kbd>кликните ПКМ</kbd> на игровом объекте и выберите <kbd>Add Component ▸ Spine Model</kbd>).
-
-- Либо сперва создайте его в файле (<kbd>кликните ПКМ</kbd> в подходящем расположении в браузере *Assets*, затем выберите <kbd>New... ▸ Spine Model</kbd> из контекстного меню), после чего добавьте этот файл к игровому объекту, <kbd>кликнув ПКМ</kbd> по игровому объекту и выбрав <kbd>Add Component File</kbd>).
-
-## Свойства Spine-модели
-
-Помимо свойств *Id*, *Position* и *Rotation* существуют следующие специфичные для компонента свойства:
-
-*Spine scene*
-: Укажите в этом свойстве файл Spine Scene, созданный раннее.
-
-*Blend Mode*
-: Если необходимо использовать режим наложения, отличный от стандартного `Alpha`, измените это свойство.
-
-*Material*
-: Если необходимо визуализировать модель с пользовательским материалом, измените это свойство.
-
-*Default animation*
-: Укажите в этом свойстве анимацию в качестве стартовой для этой модели.
-
-*Skin*
-: Если модель имеет скины, выберите один в качестве стартового.
-
-Теперь Spine-модель можно просматривать в редакторе:
-
-![Spine model in editor](images/spinemodel/spinemodel.png){srcset="images/spinemodel/[email protected] 2x"}
-
-### Режимы наложения
-:[blend-modes](../shared/blend-modes.md)
-
-## Манипулирование при выполнении
-
-Манипулировать Spine-моделями во время выполнения можно с помощью ряда различных функций и свойств (обращайтесь к [документации по API](/ref/spine/)).
-
-### Анимация во время выполнения
-
-Defold предоставляет мощную поддержку для управления анимацией во время выполнения. За подробностями обращайтесь к [руководству по анимации Spine-моделей](/manuals/spine).
-
-### Изменение свойств
-
-Spine-модель также имеет ряд различных свойств, которыми можно манипулировать с помощью `go.get()` и `go.set()`:
-
-`animation`
-: Текущая анимация модели (`hash`, только для чтения). Анимация изменяется с помощью `spine.play_anim()` (см. [руководство по Spine-анимации](/manuals/spine)).
-
-`cursor`
-: Нормализованный курсор анимации (`number`).
-
-`material`
-: Материал Spine-модели (`hash`). Это свойство можно изменить с помощью свойства ресурса Material и `go.set()`. За примером обращайтесь к [справочнику по API](/ref/spine/#material).
-
-`playback_rate`
-: Скорость воспроизведения анимации (`number`).
-
-`skin`
-: Текущий скин компонента (`hash`).
-
-## Константы материала
-
-{% include shared/material-constants.md component='spine' variable='tint' %}
-
-`tint`
-: Цветовой оттенок Spine-модели (`vector4`). Для представления оттенка с компонентами x, y, z и w, соответствующими красному, зеленому, синему и альфа оттенкам, используется тип vector4.
-
-## Конфигурация проекта
-
-В файле *game.project* имеются несколько [настроек проекта](/manuals/project-settings#spine), относящихся к Spine-моделям.

docs/zh/manuals/animation.md

@@ -8,6 +8,5 @@ brief: 本教程介绍了 Defold 的动画支持.
 Defold 内置组件支持多种动画:
 
 * [逐帧动画](/manuals/flipbook-animation) - 按顺序显示图片而形成的动画
-* [Spine 动画](/manuals/spine) - 2D 骨骼动画
 * [3D 模型动画](/manuals/model-animation) - 3D 蒙皮动画
 * [属性动画](/manuals/property-animation) - 以position, scale, rotation 等属性插值变换而形成的动画

docs/zh/manuals/glossary.md

@@ -151,14 +151,6 @@ msg.post("#weapon", "disable")
 
 ![Sound](images/icons/sound.png){.left} 声音组件用于播放声音. 目前 Defold 支持 WAV 和 Ogg Vorbis 格式的声音文件. 详情请见 [声音教程](/manuals/sound).
 
-## Spine model
-
-![Spine model](images/icons/spine-model.png){.left} Spine model 组件用于在 Defold 中使用 Spine 骨骼动画. 详情请见 [Spine 模型教程](/manuals/spinemodel).
-
-## Spine scene
-
-![Spine scene](images/icons/spine-scene.png){.left} Spine scene 资源把 Spine JSON 数据文件与 Defold 图集资源文件结合起来填充 Spine 骨架. 详情请见 [Spine 动画教程](/manuals/spine).
-
 ## Sprite
 
 ![Sprite](images/icons/sprite.png){.left} Sprite 可以使游戏对象显示出图像. 它使用瓷砖图源或者图集资源的数据显示图像. Sprite 也支持逐帧动画. 它常常被用于显示人物, 物品等.