All Korean manuals moved and images fixed.

"publish.sh" added
Language settings json files added for localized menus and metadata.
Language-map generated for quick lookup what translations exist for a path.

README.md

@@ -1,27 +1,33 @@
 # Defold manuals
 
-This repo holds the markdown source files and assets for Defold documentation.
+This repo holds the markdown source files and assets for Defold documentation. Each language has its own subfolder in "docs".
 
 ## Dependencies
 
-```
-npm install
+Node.js:
+
+```sh
+$ npm install
 ```
 
-Publishing documentation is done with the `gsutil` which is part of the Google Cloud SDK.,
+Publishing documentation is done with the `gsutil` which is part of the Google Cloud SDK:
+
+```sh
+$ ./install_deps
+```
 
 ## Edit and preview
 
-```
-gulp watch
+```sh
+$ gulp watch
 ```
 
 Builds all documentation for preview and opens a browser pointing to the build root. Edits to any .md manual or image is detected, rebuilt and reloaded in browser.
 
 ## Publish
 
-```
-gulp publish
-```
+Builds all docs and publishes them onto GCS.
 
-Not yet in place!
+```sh
+$ gulp publish
+```

docs/en/en.json

@@ -0,0 +1,246 @@
+{
+    "navigation": {
+        "tutorials":
+        [
+        ],
+        "manuals":
+        [
+            {
+                "name": "GETTING STARTED",
+                "items": [
+                    {
+                        "path": "introduction",
+                        "name": "Introduction"
+                    },
+                    {
+                        "path": "scene-editing",
+                        "name": "Scene editing"
+                    },
+                    {
+                        "path": "workflow",
+                        "name": "Workflow"
+                    },
+                    {
+                        "path": "lua",
+                        "name": "Lua in Defold"
+                    }
+                ]
+            },
+            {
+                "name": "CORE CONCEPTS",
+                "items": [
+                    {
+                        "path": "building-blocks",
+                        "name": "Building blocks"
+                    },
+                    {
+                        "path": "message-passing",
+                        "name": "Message passing"
+                    },
+                    {
+                        "path": "application-lifecycle",
+                        "name": "Application lifecycle"
+                    }
+                ]
+            },
+            {
+                "name": "RESOURCES & COMPONENTS",
+                "items": [
+                    {
+                        "path": "2dgraphics",
+                        "name": "2D graphics"
+                    },
+                    {
+                        "path": "3dgraphics",
+                        "name": "3D graphics"
+                    },
+                    {
+                        "path": "animation",
+                        "name": "Animation"
+                    },
+                    {
+                        "path": "spine",
+                        "name": "Spine animation"
+                    },
+                    {
+                        "path": "spinemodel",
+                        "name": "Spine model"
+                    },
+                    {
+                        "path": "model",
+                        "name": "Model (3D)"
+                    },
+                    {
+                        "path": "particlefx",
+                        "name": "Particle FX"
+                    },
+                    {
+                        "path": "physics",
+                        "name": "Physics"
+                    },
+                    {
+                        "path": "sound",
+                        "name": "Sound"
+                    },
+                    {
+                        "path": "font",
+                        "name": "Font"
+                    },
+                    {
+                        "path": "label",
+                        "name": "Label"
+                    },
+                    {
+                        "path": "material",
+                        "name": "Material"
+                    },
+                    {
+                        "path": "rendering",
+                        "name": "Rendering"
+                    },
+                    {
+                        "path": "shader",
+                        "name": "Shader"
+                    },
+                    {
+                        "path": "factory",
+                        "name": "Factory"
+                    },
+                    {
+                        "path": "collection-factory",
+                        "name": "Collection factory"
+                    },
+                    {
+                        "path": "collection-proxy",
+                        "name": "Collection proxy"
+                    },
+                    {
+                        "path": "live-update",
+                        "name": "Live update"
+                    },
+                    {
+                        "path": "camera",
+                        "name": "Camera"
+                    }
+                ]
+            },
+            {
+                "name": "GUI",
+                "items": [
+                    {
+                        "path": "gui",
+                        "name": "GUI overview"
+                    },
+                    {
+                        "path": "gui-text",
+                        "name": "Text nodes"
+                    },
+                    {
+                        "path": "gui-pie",
+                        "name": "Pie nodes"
+                    },
+                    {
+                        "path": "gui-spine",
+                        "name": "Spine nodes"
+                    },
+                    {
+                        "path": "gui-templates",
+                        "name": "Template nodes"
+                    },
+                    {
+                        "path": "clipping",
+                        "name": "Clipping"
+                    },
+                    {
+                        "path": "layouts",
+                        "name": "Layouts"
+                    }
+                ]
+            },
+            {
+                "name": "GAME LOGIC",
+                "items": [
+                    {
+                        "path": "properties",
+                        "name": "Properties"
+                    },
+                    {
+                        "path": "script-properties",
+                        "name": "Script properties"
+                    },
+                    {
+                        "path": "input",
+                        "name": "Input"
+                    },
+                    {
+                        "path": "debugging",
+                        "name": "Debugging"
+                    },
+                    {
+                        "path": "modules",
+                        "name": "Modules"
+                    }
+                ]
+            },
+            {
+                "name": "PROJECT SETUP",
+                "items": [
+                    {
+                        "path": "project-settings",
+                        "name": "Project settings"
+                    },
+                    {
+                        "path": "libraries",
+                        "name": "Libraries"
+                    },
+                    {
+                        "path": "texture-profiles",
+                        "name": "Texture profiles"
+                    },
+                    {
+                        "path": "bob",
+                        "name": "Bob the builder"
+                    }
+                ]
+            },
+            {
+                "name": "PLATFORMS",
+                "items": [
+                    {
+                        "path": "ios",
+                        "name": "iOS"
+                    },
+                    {
+                        "path": "android",
+                        "name": "Android"
+                    },
+                    {
+                        "path": "html5",
+                        "name": "HTML5"
+                    }
+                ]
+            },
+            {
+                "name": "EXTENSIONS",
+                "items": [
+                    {
+                        "path": "extensions",
+                        "name": "Native extensions"
+                    },
+                    {
+                        "path": "facebook",
+                        "name": "Facebook"
+                    },
+                    {
+                        "path": "iap",
+                        "name": "In-app purchases"
+                    },
+                    {
+                        "path": "push",
+                        "name": "Push notifications"
+                    }
+                ]
+            }
+        ]
+    },
+}

docs/en/manuals/gui.md

@@ -51,7 +51,7 @@ Each node has an extensive set of properties that control its appearance:
 * Adjust mode, Pivot, Xanchor, Yanchor
 * Font, Text, Line-break (for text nodes)
 * Index, Layer, Parent
-* Clipping (for box and pie nodes) (See the [Clipping documentation](/manuals/clipping) for details)
+* Clipping (for box and pie nodes) (See the [Clipping documentation](/manuals/gui-clipping) for details)
 
 These properties can be modified in the editor's properties tab (except index and parenting), or through script (see [GUI API reference](/ref/gui)).
 

docs/en/manuals/iap.md

@@ -4,7 +4,6 @@ brief: In-app purchases (or in-app billing) allows you to charge your players or
 ---
 
 # In-app purchases
-================
 
 Defold provides a unified, simple to use interface to Apple's iOS Appstore "in-app purchases" and Google Play's or Amazon's "in-app billing" on Android devices. Facebook Canvas "game payments" is supported for Facebook Canvas. These services gives you the opportunity to sell products as:
 

docs/en/manuals_navigation.json

@@ -1,242 +0,0 @@
-{
-    "name": "Manuals",
-    "menu":
-    [
-        {
-            "name": "GETTING STARTED",
-            "items": [
-                {
-                    "path": "introduction",
-                    "name": "Introduction"
-                },
-                {
-                    "path": "scene-editing",
-                    "name": "Scene editing"
-                },
-                {
-                    "path": "workflow",
-                    "name": "Workflow"
-                },
-                {
-                    "path": "lua",
-                    "name": "Lua in Defold"
-                }
-            ]
-        },
-        {
-            "name": "CORE CONCEPTS",
-            "items": [
-                {
-                    "path": "building-blocks",
-                    "name": "Building blocks"
-                },
-                {
-                    "path": "message-passing",
-                    "name": "Message passing"
-                },
-                {
-                    "path": "application-lifecycle",
-                    "name": "Application lifecycle"
-                }
-            ]
-        },
-        {
-            "name": "RESOURCES & COMPONENTS",
-            "items": [
-                {
-                    "path": "2dgraphics",
-                    "name": "2D graphics"
-                },
-                {
-                    "path": "3dgraphics",
-                    "name": "3D graphics"
-                },
-                {
-                    "path": "animation",
-                    "name": "Animation"
-                },
-                {
-                    "path": "spine",
-                    "name": "Spine animation"
-                },
-                {
-                    "path": "spinemodel",
-                    "name": "Spine model"
-                },
-                {
-                    "path": "model",
-                    "name": "Model (3D)"
-                },
-                {
-                    "path": "particlefx",
-                    "name": "Particle FX"
-                },
-                {
-                    "path": "physics",
-                    "name": "Physics"
-                },
-                {
-                    "path": "sound",
-                    "name": "Sound"
-                },
-                {
-                    "path": "font",
-                    "name": "Font"
-                },
-                {
-                    "path": "label",
-                    "name": "Label"
-                },
-                {
-                    "path": "material",
-                    "name": "Material"
-                },
-                {
-                    "path": "rendering",
-                    "name": "Rendering"
-                },
-                {
-                    "path": "shader",
-                    "name": "Shader"
-                },
-                {
-                    "path": "factory",
-                    "name": "Factory"
-                },
-                {
-                    "path": "collection-factory",
-                    "name": "Collection factory"
-                },
-                {
-                    "path": "collection-proxy",
-                    "name": "Collection proxy"
-                },
-                {
-                    "path": "live-update",
-                    "name": "Live update"
-                },
-                {
-                    "path": "camera",
-                    "name": "Camera"
-                }
-            ]
-        },
-        {
-            "name": "GUI",
-            "items": [
-                {
-                    "path": "gui",
-                    "name": "GUI overview"
-                },
-                {
-                    "path": "gui-text",
-                    "name": "Text nodes"
-                },
-                {
-                    "path": "gui-pie",
-                    "name": "Pie nodes"
-                },
-                {
-                    "path": "gui-spine",
-                    "name": "Spine nodes"
-                },
-                {
-                    "path": "gui-templates",
-                    "name": "Template nodes"
-                },
-                {
-                    "path": "clipping",
-                    "name": "Clipping"
-                },
-                {
-                    "path": "layouts",
-                    "name": "Layouts"
-                }
-            ]
-        },
-        {
-            "name": "GAME LOGIC",
-            "items": [
-                {
-                    "path": "properties",
-                    "name": "Properties"
-                },
-                {
-                    "path": "script-properties",
-                    "name": "Script properties"
-                },
-                {
-                    "path": "input",
-                    "name": "Input"
-                },
-                {
-                    "path": "debugging",
-                    "name": "Debugging"
-                },
-                {
-                    "path": "modules",
-                    "name": "Modules"
-                }
-            ]
-        },
-        {
-            "name": "PROJECT SETUP",
-            "items": [
-                {
-                    "path": "project-settings",
-                    "name": "Project settings"
-                },
-                {
-                    "path": "libraries",
-                    "name": "Libraries"
-                },
-                {
-                    "path": "texture-profiles",
-                    "name": "Texture profiles"
-                },
-                {
-                    "path": "bob",
-                    "name": "Bob the builder"
-                }
-            ]
-        },
-        {
-            "name": "PLATFORMS",
-            "items": [
-                {
-                    "path": "ios",
-                    "name": "iOS"
-                },
-                {
-                    "path": "android",
-                    "name": "Android"
-                },
-                {
-                    "path": "html5",
-                    "name": "HTML5"
-                }
-            ]
-        },
-        {
-            "name": "EXTENSIONS",
-            "items": [
-                {
-                    "path": "extensions",
-                    "name": "Native extensions"
-                },
-                {
-                    "path": "facebook",
-                    "name": "Facebook"
-                },
-                {
-                    "path": "iap",
-                    "name": "In-app purchases"
-                },
-                {
-                    "path": "push",
-                    "name": "Push notifications"
-                }
-            ]
-        }
-    ]
-}

docs/ko/ko.json

@@ -0,0 +1,251 @@
+{
+    "terms": {
+        "manuals": "Manuals",
+        "tutorials": "Tutorials",
+        "quicknav": "Quicknav"
+    },
+    "navigation": {
+        "tutorials":
+        [
+        ],
+        "manuals":
+        [
+            {
+                "name": "GETTING STARTED",
+                "items": [
+                    {
+                        "path": "introduction",
+                        "name": "Introduction"
+                    },
+                    {
+                        "path": "scene-editing",
+                        "name": "Scene editing"
+                    },
+                    {
+                        "path": "workflow",
+                        "name": "Workflow"
+                    },
+                    {
+                        "path": "lua",
+                        "name": "Lua in Defold"
+                    }
+                ]
+            },
+            {
+                "name": "CORE CONCEPTS",
+                "items": [
+                    {
+                        "path": "building-blocks",
+                        "name": "Building blocks"
+                    },
+                    {
+                        "path": "message-passing",
+                        "name": "Message passing"
+                    },
+                    {
+                        "path": "application-lifecycle",
+                        "name": "Application lifecycle"
+                    }
+                ]
+            },
+            {
+                "name": "RESOURCES & COMPONENTS",
+                "items": [
+                    {
+                        "path": "2dgraphics",
+                        "name": "2D graphics"
+                    },
+                    {
+                        "path": "3dgraphics",
+                        "name": "3D graphics"
+                    },
+                    {
+                        "path": "animation",
+                        "name": "Animation"
+                    },
+                    {
+                        "path": "spine",
+                        "name": "Spine animation"
+                    },
+                    {
+                        "path": "spinemodel",
+                        "name": "Spine model"
+                    },
+                    {
+                        "path": "model",
+                        "name": "Model (3D)"
+                    },
+                    {
+                        "path": "particlefx",
+                        "name": "Particle FX"
+                    },
+                    {
+                        "path": "physics",
+                        "name": "Physics"
+                    },
+                    {
+                        "path": "sound",
+                        "name": "Sound"
+                    },
+                    {
+                        "path": "font",
+                        "name": "Font"
+                    },
+                    {
+                        "path": "label",
+                        "name": "Label"
+                    },
+                    {
+                        "path": "material",
+                        "name": "Material"
+                    },
+                    {
+                        "path": "rendering",
+                        "name": "Rendering"
+                    },
+                    {
+                        "path": "shader",
+                        "name": "Shader"
+                    },
+                    {
+                        "path": "factory",
+                        "name": "Factory"
+                    },
+                    {
+                        "path": "collection-factory",
+                        "name": "Collection factory"
+                    },
+                    {
+                        "path": "collection-proxy",
+                        "name": "Collection proxy"
+                    },
+                    {
+                        "path": "live-update",
+                        "name": "Live update"
+                    },
+                    {
+                        "path": "camera",
+                        "name": "Camera"
+                    }
+                ]
+            },
+            {
+                "name": "GUI",
+                "items": [
+                    {
+                        "path": "gui",
+                        "name": "GUI overview"
+                    },
+                    {
+                        "path": "gui-text",
+                        "name": "Text nodes"
+                    },
+                    {
+                        "path": "gui-pie",
+                        "name": "Pie nodes"
+                    },
+                    {
+                        "path": "gui-spine",
+                        "name": "Spine nodes"
+                    },
+                    {
+                        "path": "gui-templates",
+                        "name": "Template nodes"
+                    },
+                    {
+                        "path": "clipping",
+                        "name": "Clipping"
+                    },
+                    {
+                        "path": "layouts",
+                        "name": "Layouts"
+                    }
+                ]
+            },
+            {
+                "name": "GAME LOGIC",
+                "items": [
+                    {
+                        "path": "properties",
+                        "name": "Properties"
+                    },
+                    {
+                        "path": "script-properties",
+                        "name": "Script properties"
+                    },
+                    {
+                        "path": "input",
+                        "name": "Input"
+                    },
+                    {
+                        "path": "debugging",
+                        "name": "Debugging"
+                    },
+                    {
+                        "path": "modules",
+                        "name": "Modules"
+                    }
+                ]
+            },
+            {
+                "name": "PROJECT SETUP",
+                "items": [
+                    {
+                        "path": "project-settings",
+                        "name": "Project settings"
+                    },
+                    {
+                        "path": "libraries",
+                        "name": "Libraries"
+                    },
+                    {
+                        "path": "texture-profiles",
+                        "name": "Texture profiles"
+                    },
+                    {
+                        "path": "bob",
+                        "name": "Bob the builder"
+                    }
+                ]
+            },
+            {
+                "name": "PLATFORMS",
+                "items": [
+                    {
+                        "path": "ios",
+                        "name": "iOS"
+                    },
+                    {
+                        "path": "android",
+                        "name": "Android"
+                    },
+                    {
+                        "path": "html5",
+                        "name": "HTML5"
+                    }
+                ]
+            },
+            {
+                "name": "EXTENSIONS",
+                "items": [
+                    {
+                        "path": "extensions",
+                        "name": "Native extensions"
+                    },
+                    {
+                        "path": "facebook",
+                        "name": "Facebook"
+                    },
+                    {
+                        "path": "iap",
+                        "name": "In-app purchases"
+                    },
+                    {
+                        "path": "push",
+                        "name": "Push notifications"
+                    }
+                ]
+            }
+        ]
+    },
+}

docs/ko/manuals/2dgraphics.md

@@ -0,0 +1,213 @@
+# 2D Graphics
+2D 게임은 일반적으로 많은 이미지를 사용하여 만들어지며, 플립-북 애니메이션이나 복잡한 스파인(Spine) 애니메이션에 사용되거나 타일맵의 레벨이나 배경에 매핑되기도 합니다. 이 메뉴얼에서는 Defold가 지원하는 2D 그래픽 요소에 대해 자세히 알아보도록 합니다.
+
+성능상의 이유로, 다수의 이미지들을 하나 혹은 몇 개의 큰 이미지로 병합하여, 작은 원본 이미지를 어떤 큰 이미지의 서브-이미지로 참조할 수 있습니다. 작은 이미지들을 큰 이미지로 병합하는 것은 데스크탑PC나 콘솔게임기에 비해 메모리와 전력이 부족한 모바일 디바이스에서 특히 중요합니다.
+
+Defold에는 큰 이미지를 나타내는 두 가지 방식의 에셋이 있습니다:
+
+#### Atlases
+아틀라스는 이미지들의 목록을 포함하고 있으며, 자동적으로 큰 이미지로 병합합니다. 자세한 것은 http://en.wikipedia.org/wiki/Texture_atlas 를 참고하세요.
+
+#### Tile Sources
+타일 소스는 균일한 격자(grid)에 정렬된 서브-이미지들을 이미 포함하고 있는 이미지 파일을 참조합니다. 다른 툴에서는 타일셋(tile set)이나 스프라이트시트(sprite sheet)라는 용어를 사용합니다. 자세한 것은 http://en.wikipedia.org/wiki/Tileset#Tile_set 를 참고하세요.
+
+## Importing Image Files
+Defold에서 에셋을 사용하려면 프로젝트 계층구조(project hierarchy)에 있어야 하므로, 그래픽에 쓰일 이미지 파일을 임포트 해야 합니다. 이미지 에셋을 임포트하기 위해서는 그냥 당신의 컴퓨터 파일 시스템에서 Defold 에디터의 프로젝트 익스플로러 창(Project Explorer)의 적당한 위치로 드래그-앤-드롭 하면 됩니다.
+
+> 현재, Defold는 오직 PNG 이미지 포멧 만을 지원합니다.
+
+![Importing image files](images/2dgraphics/2dgraphics_import1.png)
+
+![Importing image files](images/2dgraphics/2dgraphics_import2.png)
+
+## Creating an Atlas
+아틀라스를 사용하기 전에, 먼저 아틀라스에 이미지를 채우는 것이 필요합니다. 아틀라스에 이미지나 애니메이션을 추가하면, 스프라이트나 파티클FX 컴포넌트와 같이 오브젝트 컴포넌트에 그래픽 소스로 사용 할 수 있습니다. (아래의 Sprite 와 ParticleFX 가이드 참고)
+
+1. 위에서 설명한대로 이미지 파일들을 임포트 하기
+2. 프로젝트 익스플로러 창(Project Explorer)에서 마우스 오른쪽 버튼을 눌러 **New > Atlas File** 선택하기
+3. 아웃라인 창(Outline)에서 마우스 오른쪽 버튼을 눌러 **Add Images** 선택하기
+
+이렇게 하면 아틀라스에 추가하길 원하는 이미지들을 검색하고 선택할 수 있는 대화상자가 열리게 됩니다. 이미지 파일을 필터링하거나 한 번에 여러 파일들을 선택할 수 있습니다.
+
+![Creating an atlas, adding images](images/2dgraphics/2dgraphics_atlas_add.png)
+
+![Creating an atlas](images/2dgraphics/2dgraphics_atlas.png)
+
+#### Defining flip-book animations
+아틀라스에서 하위 이미지들을 선탁해여 플립-북 애니메이션을 정의 할 수 있습니다:
+
+1. 아웃라인 창(Outline)에서 마우스 오른쪽 버튼을 눌러 **Add Animation Group** 선택하기
+2. 생성된 애니메이션 그룹에 마우스 오른쪽 버튼을 눌러 **Add Images**를 누르고 애니메이션의 프레임에 사용할 이미지들을 선택하기
+3. 필요한 만큼 애니메이션의 속성(**Properties**)을 조절하기
+
+필요하다면 이미지를 드래그해서 아웃라인 창의 이미지 순서를 바꿀 수 있습니다. 또한 복사 붙여넣기 신공(**Edit** 메뉴, 마우스 오른쪽 버튼, 키보드 단축키)을 사용하여 아웃라인 창의 이미지들을 쉽게 복사할 수도 있습니다. 미리보기를 하려면 해당 애니메이션을 선택하고 키보드의 **Space**키를 눌러 주세요.
+
+## Creating a Tile Source
+타일 소스를 만들려면 모든 타일을 포함하고 있는 이미지가 필요합니다. 모든 타일은 반드시 완전히 동일한 크기로 격자(grid)에 배치되어야 합니다. Defold는 각 타일 사이의 간격을 조절하는 spacing과 padding을 지원합니다. 또한 Defold는 때때로 발생하는 visual artifacts(잔상이나 플리커링 등의의 이상한 시각적 현상들)을 피하기 위해 자동적으로 외곽선을 돌출(extrude borders) 시킬 수 있습니다.
+
+이미지 소스가 준비되면 아래 방법으로 타일 소스를 만들 수 있습니다:
+
+1. 이미지를 프로젝트 익스플로러 창(Project Explorer)으로 드래그하여 프로젝트에 임포트합니다.
+2. 새 타일 소스(Tile Source) 파일을 생성합니다.
+3. 속성창의 **Image** 속성에서 검색[...] 버튼을 눌러 이미지를 선택합니다. 이제 이미지가 에디터에 표시됩니다.
+4. 타일의 높이(**Tile Height**)나, 넓이(**Tile Width**), 마진(**Tile Margin**), 간격(**Tile Spacing**)을 원본 이미지에 알맞게 조절합니다. 각 셀이 투명한 그리드에 정확하게 정렬되면 모든 것이 올바르게 설정된 것입니다.
+
+![Creating a Tile Source](images/2dgraphics/2dgraphics_tilesource.png)
+
+> 선형 필터링(linear filtering - 아래 참조)과 함께 타일들이 다닥 다닥 붙어있는(외곽선이 없는) 타일 소스를 사용하면 edge bleeding으로 불리는 visual artifact가 발생할 위험이 있습니다. 만약 이웃한 타일의 가장자리가 컬러가 있는 픽셀로 되어 있다면, 이 가장자리 부분의 색상이 흘러 넘치는 것 처럼 이상하게 보일 수도 있습니다. 이 문제를 해결하기 위한 가장 쉬운 방법은 **Extrude Border** 속성(아틀라스나 타일 소스에서 찾을 수 있음)을 설정하는 것입니다. 이 값은 가장자리의 픽셀이 게임 실행에 사용된 최종 텍스쳐에서 자동적으로 몇 번이나 복제되어야 하는 지를 지정합니다.
+
+> 좋은 측정방법은 게임이 보여질 때 텍스쳐의 크기를 얼만큼 조절할지에 알맞는 숫자를 명시하는 것입니다. 게임월드를 절반 크기로 나타내려면 **Extrude Borders**를 2로 설정하면 됩니다. 텍스처를 절반 크기로 줄여서 사용하면, 렌더링에 밉맵(mipmap)이 사용됩니다. 이 밉맵은 원본 이미지의 넓이와 높이가 절반입니다.
+
+## Tile Source Collision Shapes
+타일 맵(Tile Map)을 사용하여 물리 상호작용을 활성화하는 충돌 영역(Collision shape)은 자동적으로 생성될 수 있습니다. Defold는 **Collision** 속성에 명시된 이미지로부터 각 타일에 볼록한 영역(Convex shape)을 생성하기 위해 알파 채널(alpha channel)을 사용합니다. 이 속성에는 이미지와 똑같은 충돌 영역을 위해 동일한 이미지를 사용하여 충돌 영역을 생성하는 것이 대부분이겠지만, 보이는 것과 다른 충돌 영역을 원한다면 다른 이미지를 선택해도 됩니다. 충돌(collision) 이미지를 지정하면, 생성된 충돌 영역을 나타내는 각 타일의 윤곽선으로 미리보기가 업데이트 됩니다. 자세한 것은 [Physics](Physics) 문서를 참고 바랍니다.
+
+![Collision Shapes](images/2dgraphics/2dgraphics_tilesource_collision.png)
+
+## Tile Source flip-book animations
+타일 소스에 애니메이션을 정의하려면 각 프레임에 타일을 하나 씩 할당(동일한 넓이와 높이로 격자에 들어맞게)해야 하며 왼쪽에서 오른쪽 순서로 나란히 놓아야 합니다. 다음 줄로 행이 넘어가면 다시 맨 왼쪽부터 시작됩니다. 새로 생성된 타일 소스에는 "anim"이라고 하는 기본 애니메이션이 있습니다. 이것을 클릭하면 이름(id), 시작과 끝 프레임(Start Tile, End Tile), 재생(Playback) 방법 및 속도(Fps), 애니메이션이 가로나 세로로 뒤집혀야 하는지(Flip Horizontally, Flip Vertically)를 설정하는 애니메이션 속성창(**Properties**)이 나타납니다.
+
+![Tile Source add animation](images/2dgraphics/2dgraphics_tilesource_animation.png)
+
+아웃라인(Outline) 창의 **Tile Source**를 마우스 오른쪽 클릭하여 컨텍스트 메뉴를 열고 **Add Animation**를 선택하여 타일 소스에 애니메이션을 쉽게 더 추가할 수 있습니다.
+
+![Tile Source animation](images/2dgraphics/2dgraphics_tilesource_add_animation.png)
+
+## Manipulating Game Objects and components
+게임 오브젝트에 시각적 구성요소(스프라이트, 파티클FX 등)를 추가하면, 컴포넌트의 위치값과 회전 값을 설정할 수 있습니다. 이 값은 게임 오브젝트의 위치, 회전에 대한 오프셋으로 사용됩니다. 게다가 이 값은 게임 오브젝트를 조립(assemble)할때 컴포넌트에 설정 됩니다.
+
+![Component position](images/2dgraphics/2dgraphics_component_position.png)
+
+Defold의 게임 오브젝트는 이동, 회전이 가능하며 이 속성들을 애니메이션 처리 할 수 있습니다. 게임 오브젝트를 이동, 회전하면 하위의 컴포넌트도 같이 움직이게 되지만, 게임 오브젝트에 상대적인 위치값과 회전값(relative position and rotation)은 유지됩니다. 컴포넌트는 끄고 켤 수 있지만 동적으로 이동, 회전하거나 애니메이션 효과를 주는것은 불가능합니다(아래의 예외사항 참고). 그러므로 그래픽의 위치, 회전을 변경하길 원한다면 별도의 게임오브젝트로 집어 넣어야 합니다. 게임 오브젝트의 그룹이나 게임오브젝트 계층(hierarchy)은 컬렉션에 편리하게 조립(assemble)된 후 이 오브젝트들을 스크립트를 통해 자유롭게 다룰 수 있습니다:
+
+![Component position](images/2dgraphics/2dgraphics_gameobject_position.png)
+
+```lua
+    -- wand 게임 오브젝트에 이동, 회전 애니메이션 시키기
+    go.animate("wand", "position", go.PLAYBACK_ONCE_FORWARD, vmath.vector3(530, 79, -0.1), go.EASING_INOUTSINE, 0.5)
+    go.animate("wand", "euler", go.PLAYBACK_ONCE_FORWARD, vmath.vector3(0, 0, -70), go.EASING_INOUTSINE, 0.5)
+```
+
+## Dynamically scaling Sprites
+스프라이트 컴포넌트의 크기를 동적으로 변경하는 것이 가능합니다. 이 기능은 게임 오브젝트와 컴포넌트가 어떻게 서로 연관되어 동작하는지 작동 방식의 이해(mental model)가 조금 어려울 수 있습니다.
+
+스프라이트는 vmatch.vector3 타입인 "scale" 프로퍼티를 가지고 있습니다. 이 컴포넌트에 아래처럼 애니메이션 효과를 줄 수 있습니다:
+
+```lua
+go.animate("my_object#sprite", "scale.x", go.PLAYBACK_ONCE_FORWARD, 1.5, go.EASING_INOUTSINE, 2)
+```
+
+## Sprites
+스프라이트 컴포넌트는 그래픽이나 플립북 애니메이션을 게임 오브젝트에 추가하는데 사용됩니다. 일반적으로 캐릭터나 소품(props)들을 만드는 데 쓰이며, 스프라이트 컴포넌트를 만드는 것은 매우 간단합니다:
+
+1. 스프라이트가 속할 게임오브젝트를 생성하거나 열기
+2. 아웃라인 창에서 게임 오브젝트에 마우스 오른쪽 버튼 눌러서 **Add Component** 선택하기
+3. "Sprite" 선택하기
+4. 스프라이트의 **Image** 속성을 타일소스나 아틀라스로 지정하기
+5. 스프라이트의 **Default Animation** 속성을 기본적으로 플레이할 애니메이션으로 지정하기
+
+기본 애니메이션은 게임 실행중에 게임 오브젝트가 생성되면 플레이 됩니다. 만약 이미지 리소스로 아틀라스를 사용중이라면 **Default Animation** 속성의 드롭다운 메뉴를 통해서 이미지들을 볼 수 있습니다. 타일 소스에 있는 이미지로부터 스프라이트를 만들고 싶다면, 1 프레임 짜리 애니메이션을 만들고 **Playback** 속성을 "None"으로 설정하면 됩니다.
+
+#### Collision Shapes
+스프라이트는 아직 타일소스에서 충돌모형(Collision Shape)을 자동생성하는 것을 지원하지 않습니다. 대신, 다른 게임 오브젝트와 마찬가지로 충돌 모형(Collision Shape)을 사용하여 충돌 오브젝트(Collision Object)를 추가할 수 있습니다. 자세한 것은 [Physics](Physics) 문서를 참고 바랍니다.
+
+#### Blend Mode
+블렌드 모드 속성은 스프라이트가 뒤쪽에 겹쳐진 그래픽과 어떻게 혼합(blend)할지 정의하는 속성입니다. 아래에 사용 가능한 블렌드 모드의 종류와 각각 어떻게 계산되는지에 대한 설명이 있습니다:
+
+###### Alpha
+기본 블렌딩: a0 * rgb0 + (1 - a0) * rgb1
+###### Add
+해당 스프라이트 픽셀의 컬러값을 이용해 배경을 밝게 함: rgb0 + rgb1
+###### Add Alpha
+보여지는(visible) 스프라이트 픽셀의 컬러값을 이용해 배경을 밝게 함: a0 * rgb0 + rgb1
+###### Multiply
+해당 스프라이트 픽셀의 컬러값을 이용하여 배경을 어둡게 함: rgb0 * rgb1
+
+#### Sprite Shading
+기본 스프라이트 쉐이딩 파일은 프로젝트의 "/builtins/material/sprite.*" 에 있습니다. 기본 쉐이딩은 표준 텍스쳐 색상 보정(regular texture lookup)을 수행하지만 텍스쳐 색상과 겹쳐지는(multiply) 색조(tint: fragment shader constant) 또한 가지게 됩니다.
+
+클릭시 스프라이트를 하얗게 번쩍이는 것과 같은 효과를 주기 위해 커스텀 쉐이딩을 구현할 수 있습니다. 스프라이트에 커스텀 쉐이딩을 설정하기 위해 아래 단계를 따라해 봅시다:
+
+1. "/builtins/material/sprite.*" 의 파일들을 당신의 프로젝트 디렉토리 중 하나("built-in" 디렉토리의 컨텐츠는 수정 할 수 없습니다.)에 복사합니다. 이것은 정해진 방식은 아니지만 작업을 더 쉽게 만듭니다.
+2. 복사한 "sprite.material" 파일을 열어, 위에서 복사한 쉐이더 파일(.vp와 .fp 파일)의 경로로 다시 매핑(remap)합니다.
+3. 복사한 쉐이더 파일(.vp와 .fp 파일)을 원하는 대로 수정합니다. 만약 쉐이더 상수(shader constants)를 사용하려면 반드시 메터리얼(material) 파일에 선언되어야 합니다.
+4. 스프라이트를 열어서 속성창(Properties)에서 새 메터리얼로 지정해줍니다.
+5. 게임 실행 중에 쉐이더 상수(shader constants)를 설정하려면,  sprite.set_constant() 함수와 sprite.reset_contant() 함수를 사용하면 됩니다.
+
+## Tile Maps
+타일맵은 큰 격자(grid) 공간으로 타일 소스의 타일을 조립하거나 페인팅 하게 해 주는 컴포넌트입니다. 타일맵은 일반적으로 레벨 환경을 만드는데 사용됩니다. 또한 충돌을 감지하고 물리 시뮬레이션을 위해 맵의 타일소스로부터 충돌 모형(Collision Shapes)을 사용할 수도 있습니다.
+
+#### Painting Tiles
+1. 작업하길 원하는 타일맵을 엽니다.
+2. Property 또는 Outline 창에 플래그 이슈(flagged issues)가 없는지 확인합니다.
+3. Outline 창에서 페인팅하려는 레이어를 선택하거나 생성합니다.
+4. 브러시로 사용할 타일을 선택합니다. (타일 팔레트를 보기 위해서 **Space** 키를 눌러 보세요.)
+
+![Painting tiles](images/2dgraphics/2dgraphics_tilemap.png)
+
+#### Picking Tiles
+타일맵에서 타일을 직접 선택해서 브러시를 사용할 수도 있습니다. **Shift**를 누른 채로 타일을 클릭하면 브러시가 선택됩니다. **Shift**를 누른 채로 클릭과 드래그를 사용해 타일의 구역을 선택하면 더 큰 브러시를 사용할 수 있습니다.
+
+![Picking tiles](images/2dgraphics/2dgraphics_tiles_pick.png)
+
+#### Erasing Tiles
+지우개 툴은 페인팅한 타일을 지우는데 사용됩니다. 지우개를 선택하려면 아래 방법들이 있습니다:
+
+1. 타일맵 메뉴에서 선택하기
+2. **Backspace**키 누르기
+3. 타일 팔레트에서 선택된 타일을 다시 클릭하기
+4. 타일맵에서 아무 빈 셀이나 선택하기
+
+#### Attaching Physics
+타일맵에 물리 기능을 첨부하는 것으로 타일과 관련된 충돌을 감지하거나 물리 시뮬레이션을 할 수 있습니다. 타일맵에 물리 기능을 붙이기 위해서는 [Physics](Physics) 문서를 참고 바랍니다.
+
+## Changing tiles from script
+게임이 실행되는 동안 동적으로 타일맵의 컨텐츠를 변경할 수도 있습니다. 이 작업을 위해서는 타일맵에 set_tile 메세지를 보내야 합니다:
+
+```lua
+-- 두개의 타일로 된 문짝을 "열린 문짝" 타일로 바꾸는 코드
+-- 문짝이 두 개의 타일이므로 두 번 호출 필요
+local doorpos = vmath.vector3(174, 305, 0)
+msg.post("/level#tilemap", "set_tile", { layer_id = hash("layer1"), position = doorpos, tile = 58 })
+-- 문짝의 윗부분 타일의 위치값을 기준으로 "dy"를 1로 설정해서 문짝 아랫부분 수정
+msg.post("/level#tilemap", "set_tile", { layer_id = hash("layer1"), position = doorpos, tile = 46, dy = 1 })
+```
+
+## Adding a Tile Map to your game
+게임에 타일 맵을 추가하려면:
+
+1. 타일맵 컴포넌트를 사용할 게임 오브젝트를 만듭니다. 이 게임 오브젝트는 파일로 되어 있던지 컬렉션에서 직접 생성되었던지는 상관 없습니다.
+2. 게임 오브젝트에 마우스 오른쪽 클릭 후 Add component from file 을 선택합니다.
+3. 타일맵 파일을 선택합니다.
+
+게임 오브젝트가 타일맵을 포함하고 있으며 이제 원하는 위치에 게임 오브젝트를 배치하거나 스폰 할 수 있습니다.
+
+![Placed tile map](images/2dgraphics/2dgraphics_tilemap_go.png)
+
+## Texture Filtering and Sampling
+Defold는 텍스쳐 샘플링을 위해 두가지 방식을 지원하고 있습니다. 이 방식들은 texel(텍스쳐의 픽셀)이 완벽하게 화면의 픽셀에 정렬되어 들어맞지 않는 경우에 시각적 결과(visual result)를 제어하는데, 이 문제는 심리스(seamlessly: 이음새가 없는)한 텍스쳐를 포함하는 스프라이트를 움직일 경우(예를 들어 방향 상관없이 0.2픽셀을 움직여 보면...) 이거나 카메라를 심리스하게 움직이거나 줌 인/아웃 할 경우 발생합니다:
+
+#### Nearest
+이 방식은 가장 근접한 텍셀(nearest texel)을 선택해 화면의 픽셀을 채웁니다. 이 샘플링 방법은 텍스쳐에서 화면에 보이는 것과 일대일 매핑을 원할 경우 선택하는 것이 좋습니다. 이 근접 필터링(nearest filtering)을 사용하면 움직일 때 픽셀에서 픽셀로 모든 것이 스냅(snap)되며 스프라이트가 천천히 움직이는 경우 깜빡이게 보일 수 있습니다.
+
+#### Linear
+화면 픽셀에 컬러를 입히기 전에 텍셀은 이웃한 컬러들의 평균치를 계산합니다. 이 방식은 스프라이트가 화면에 완전하게 채색되기 이전에 픽셀로 블리드(bleed) 되므로 지속적으로 느리게 움직이거나, 부드럽게(smooth) 만드는데 사용하는 것이 좋습니다. 이 방식은 전체 픽셀보다 작은 스프라이트를 움직이는게 가능합니다.
+
+이 필터링 설정값은 Project Settings 파일에 저장되며, 여기 두 가지 설정값이 있습니다:
+
+#### default_texture_min_filter
+축소 필터링(Minifying filtering)은 텍셀이 화면 픽셀보다 작을 때 적용됩니다.
+
+#### default_texture_mag_filter
+확대 필터링(Magnifying filtering)은 텍셀이 화면 픽셀보다 클 때 적용됩니다.
+
+두 설정값 모두 linear나 nearest 값으로 설정할 수 있습니다. 예를 들어:
+
+```
+[graphics]
+default_texture_min_filter = nearest
+default_texture_mag_filter = nearest
+```
+
+아무것도 지정하지 않으면, 두 값 모두 linear 를 기본으로 설정됩니다.
+
+(그래픽 에셋 일부는 Kenney: http://kenney.nl/assets 에 의해 제작되었습니다.)

docs/ko/manuals/3dgraphics.md

@@ -0,0 +1,37 @@
+# 3D graphics
+Defold는 3D 엔진의 기능을 사용하고 있습니다. 2D 메터리얼을 사용하더라도 모든 렌더링은 3D로 처리되지만 화면에는 직교(orthographic)로 투영되어 2D 처럼 보이게 됩니다. 이 매뉴얼은 어떻게 3D 모델, 스켈레톤, 애니메이션을 게임에 불러오는지 설명합니다.
+
+Defold는 3D 에셋이나 모델을 컬렉션에 포함해서 3D 컨텐츠를 완전하게 활용하는 것이 가능합니다. 3D 에셋만을 사용해서 완전한 3D 게임을 만들 수도 있고 2D 컨텐츠와 섞어서 개발 할 수도 있습니다.
+
+## Defold resources
+
+#### Model
+모델 컴포넌트는 오브젝트 메쉬(mesh), 스켈레톤(skeleton), 애니메이션(animation)을 포함합니다. 다른 모든 시각적 컴포넌트들 처럼 메터리얼(material)과 엮어서 사용할 수 있습니다.
+
+#### Animation Set
+애니메이션 세트 파일은 애니메이션을 읽기 위해 **.dae** 파일의 목록을 포함하고 있습니다. 또한 애니메이션 세트에 **.animationset** 파일을 추가 할 수도 있으며, 이는 여러 모델들 사이의 부분 에니메이션 세트를 공유하는 경우 편리합니다.
+
+[Model](Model) 문서는 3D 에셋을 임포트하고 모델을 만드는 방법에 대해 설명합니다.
+
+[Animation](Animation) 문서는 3D 모델을 에니메이션 처리 하는 방법에 대해 설명합니다.
+
+## Collada support
+Defold의 3D 지원을 위해서는 모델, 스켈레톤, 애니메이션 데이터를 Collada 라는 포멧으로 저장하고 익스포트 해야 합니다. 이 포멧은 대부분 3D 모델링 소프트웨어에서 광범위하게 지원되고 있는  포멧입니다. 그러므로 마야, 3D맥스, 블렌더, 스케치업 등의 유명한 소프트웨어로 에셋을 생성하고 Defold로 결과 파일을 불러올 수 있게 해야 합니다.
+
+> Defold는 현재 현재 베이크 애니메이션(baked animations)만 지원합니다. 애니메이션은 키프레임마다 각각의 애니메이션 본(animated bone)을 위한 메트릭스를 가져야 하며 위치, 회전, 스케일은 별도의 키로 가지지 말아야 합니다.
+
+> 또한 애니메이션은 선형적으로 보간(linearly interpolated)됩니다. 고급 곡선 보간(curve interpolation)을 하려면 애니메이션을 익스포터(exporter)에서 미리 구워(prebake)야 합니다.
+
+> Collada의 애니메이션 클립(Animation clip)은 지원하지 않습니다. 모델별로 다수의 애니메이션을 사용하기 위해서는 각각 별도의 **.dae** 파일로 익스포트 하고 Defold의 **.animationset** 파일로 합쳐야 합니다.
+
+## Materials and textures
+일반적으로 3D 소프트웨어에서는 오브젝트가 얼마나 빛나거나 투명하게 할지 혹은 오브젝트가 털이 휘날리는지 카메라를 어디에 배치할지 카메라 렌즈를 어떻게 할지 등의 고급 메터리얼 속성을 설정할 수 있습니다. 이 모든 정보는 3D 소프트웨어에서 익스포트하는 Collada **.dae** 파일에 저장되며 오프라인으로 오브젝트를 렌더링하는 데 유용합니다. Defold 같은 실시간 게임 엔진에서는 이렇게 많은 정보는 필요하지 않으므로 Defold는 에셋 파일을 읽을 때 이 정보들을 무시합니다. 게임의 요구사항에 따라 적절하고 효과적인 메터리얼을 선택 혹은 생성 해야 하며, 의도된 게임플레이로 동작하게끔 게임 카메라를 디자인하고 구현해야 합니다.
+
+당신의 Defold 프로젝트는 렌더 스프라이트, 타일, 파티클, GUI노드에 사용되는 몇 가지 내장 메터리얼(built-in material)을 가지고 있습니다. 3D 모델을 위한 적합한 내장 메터리얼은 없으므로 직접 제작해야 합니다. 하지만 책 모델을 위해서 미리 만들어 놓은 "textured.material" 예제가 있습니다.
+
+메터리얼이 작동되는 방법과, 질감이 입혀진 3D 모델로 작업하는 방법에 대해 자세히 알고 싶다면  [Material](Material) 문서를 참고 바랍니다.
+
+## Rendering
+모델을 게임에 적용하기 위한 마지막 작업은 프로젝트의 **Render Script**를 변경하는 것입니다. 기본 렌더 스크립트는 2D 게임을 위해 맞춰져 있으며 3D 모델에는 동작하지 않습니다. 하지만 기본 렌더 스크립트를 복사해서 Lua 코드 몇 줄을 추가해서 3D 모델이 렌더링 되게 할 수 있습니다. 샘플 프로젝트의 경우 이미 이 렌더 스크립트가 셋팅되어 있습니다.
+
+렌더 스크립트가 동작하는 방법을 자세히 알고 싶다면 [Rendering](Rendering) 문서를 참고 바랍니다.

docs/ko/manuals/android.md

@@ -0,0 +1,136 @@
+# Android development
+이 문서는 Android 장치에서 Defold 어플리케이션을 빌드하고 실행하는 방법에 대해 설명합니다.
+
+Android 개발은 컨텐츠를 자유롭게 장치에 업로드 하고 액세스 할 수 있다는 점에서 iOS 개발과 다르며 아주 쉽게 게임의 버전을 빌드하고 Android 장치에 복사할 수 있습니다. 또한 와이파이를 통해 장치에서 반복적인 개발을 위한 개발용 엔진(development engine)도 쉽게 추가할 수 있습니다.
+
+## Android and Google Play signing process
+Android는 앱을 설치하기 위해 디지털 서명을 필요로 합니다. Apple에서 모든 인증서를 발행하는 iOS와는 달리, Android는 자체 서명된 앱을 허용하므로 앱을 서명하는데 필요한 키나 인증서를 자유롭게 생성할 수 있습니다.
+
+인증서나 키를 생성하는 과정은 복잡해 보일 수 있지만, 개발단계에서는 Defold가 이 과정을 완전히 자동화 합니다. 에디터에서 Android 어플리케이션 번들을 만들 때, 당신은 특정 인증서와 키를 제공할 수 있지만, 제공하지 않더라도 Defold가 무작위로 인증서와 키를 생성하고 **.apk**(Android Application Package) 파일을 서명합니다.
+
+Google Play에 앱을 릴리즈할 때가 되면 앱을 서명하는데 사용되는 실제 인증서와 키를 생성해야만 합니다. 그 이유는 이 앱의 버전을 배포하고 업데이트 하려 할 때, 엡데이트 된 **.apk** 파일과 현재 버전이 동일한 서명으로 되어있어야 하기 때문입니다. 만약 서로 다른 private key로 서명하면, Google Play는 **.apk** 업데이트를 거부(reject)하게 되고 당신은 이 게임을 완전히 새로운 앱으로 다시 배포해야 합니다.
+
+더 많은 정보는 [Google Play developer console](https://play.google.com/apps/publish/) 에서 찾을 수 있습니다. 나만의 인증서와 키를 생성하는 방법은 아래 정보를 참고 바랍니다.
+
+## Android Debug Bridge
+adb 명령 줄 도구는 Android 장치와 상호작용하는데 사용되는 다재다능한 프로그램이며 사용하기도 쉽습니다. Mac, Linux, Windows용으로 Android SDK package 에서 adb를 다운로드하고 설치할 수 있습니다.
+
+http://developer.android.com/sdk/index.html 에서 Android SDK 를 다운로드하세요. <sdk>/platform-tools/ 경로에서 adb 도구를 찾을 수 있습니다. 또는 플랫폼 별 패키지는 각각의 패키지 매니저를 통해서 설치할 수 있습니다.
+
+On Ubuntu Linux:
+```
+$ sudo apt-get install android-tools-adb
+```
+
+On Fedora 18/19:
+```
+$ sudo yum install android-tools
+```
+
+On Mac OS X (Homebrew)
+```
+$ brew install android-platform-tools
+```
+
+adb로 USB를 통해 컴퓨터와 Android 장치가 연결되었는지 확인하려면 아래 커맨드를 입력하십시오.
+
+```
+$ adb devices
+List of devices attached
+31002535c90ef000    device
+```
+
+장치(device)가 나타나지 않으면, Android에서 **USB 디버깅(USB debugging)** 이 활성화 되어 있는지 확인하세요. **설정(Settings)** 에서 **개발자 옵션(Developer options)** (또는 **Development**)에서 찾을 수 있습니다.
+
+![Enable USB debugging](images/android/usb_debugging.png)
+
+## development dmengine 설치하고 실행하기
+Defold 엔진의 stand-alone 버전은 준비된 **.apk** 파일을 무선으로 장치에 설치하고 반복적인 개발을 가능하게 해 줍니다.
+
+* http://d.defold.com에 방문해서 Defold downloads 항목을 찾습니다.
+* 다운로드할 버전을 클릭해서 사용 가능한 엔진 빌드 목록을 펼칩니다.
+* Android 플랫폼(Armv7)의 디버그 활성 빌드(debug enabled build)를 위해 "engine/armv7-android/dmengine.apk"를 선택합니다.
+
+![Download dmengine](images/android/download_dmengine.png)
+
+이 파일을 다운로드 한 후, **.apk**가 있는 위치에서 아래의 adb 명령을 실행합니다.
+
+```
+$ adb install dmengine.apk
+4445 KB/s (8706017 bytes in 1.912s)
+    pkg: /data/local/tmp/dmengine.apk
+Success
+```
+
+이제 개발용 "dmengine" 앱이 기기에 설치 되었습니다.
+
+![dmengine on the device](images/android/dmengine_on_device.png)
+
+### Launching the game
+Android 장치에서 게임을 실행하려면, dmengine 앱과 에디터가 동일한 와이파이 네트워크에 연결되어 있어야 합니다.
+
+1. 에디터가 실행중인지 확인합니다.
+2. Android에서 "dmengine" 앱을 실행합니다.
+3. 에디터의 **Project > Targets** 에서 당신의 기기를 선택합니다.
+4. **Project > Build And Launch**를 선택해서 게임을 실행합니다. 게임 컨텐츠가 네트워크를 통해 장치로 스트림 되므로 게임이 시작되는데 시간이 걸릴 수 있습니다.
+
+게임이 실행되는 동안, 평소처럼 [핫 리로드](Debugging#hot-reloading)을 사용할 수 있습니다.
+
+## Android 어플리케이션 번들 만들기
+에디터는 게임을 위한 standalone 어플리케이션 번들을 쉽게 만들 수 있게 해 줍니다. **Project > Bundle…​ > Android Application…​** 메뉴를 선택해 보세요.
+
+![Signing Android bundle](images/android/sign_bundle.png)
+
+인증서와 비공개 키(Private Key)를 선택하고 **Package** 버튼을 누르면 컴퓨터에서 번들이 생성될 위치를 지정하라는 창이 뜹니다.
+
+![Android Application Package file](images/android/apk_file.png)
+
+에디터는 Android 어플리케이션 번들인 **.apk** 파일을 생성합니다. 이 파일은 adb 도구를 사용해 기기로 복사하거나 [Google Play developer console](https://play.google.com/apps/publish/) 을 통해서 Google Play에도 복사할 수 있습니다.  "game.project" 프로젝트 설정 파일에서 버전 코드나 앱에서 사용할 아이콘 등을 지정할 수 있습니다.
+
+### 어플리케이션 번들 디버깅하기
+엔진의 디버그 모드 버전(번들 생성시에 "Release mode"를 체크 해제 했을 경우)으로 빌드된 번들은 모든 콘솔 출력(console output)을 Android 시스템 로그로 보냅니다. 이 로그는 adb 도구에 "logcat" 명령어를 사용해서 액세스 할 수 있으며 태그("-s [tagname]")를 사용해서 출력을 필터링 할 수도 있습니다.
+
+```
+$ adb logcat -s "defold"
+--------- beginning of /dev/log/system
+--------- beginning of /dev/log/main
+I/defold  ( 6210): INFO:DLIB: SSDP started (ssdp://192.168.0.97:58089, http://0.0.0.0:38637)
+I/defold  ( 6210): INFO:ENGINE: Defold Engine 1.2.50 (8d1b912)
+I/defold  ( 6210): INFO:ENGINE: Loading data from:
+I/defold  ( 6210): INFO:ENGINE: Initialised sound device 'default'
+I/defold  ( 6210):
+D/defold  ( 6210): DEBUG:SCRIPT: Hello there, log!
+...
+```
+
+## 인증서와 키 생성하기
+**pem** 포멧의 인증서와 **pk8** 포멧의 키를 생성해야 합니다. 이는 openssl 도구를 사용해 생성할 수 있습니다.
+
+```
+$ openssl genrsa -out key.pem 1024
+$ openssl req -new -key key.pem -out request.pem
+$ openssl x509 -req -days 9999 -in request.pem -signkey key.pem -out certificate.pem
+$ openssl pkcs8 -topk8 -outform DER -in key.pem -inform PEM -out key.pk8 -nocrypt
+```
+
+이렇게 해서 어플리케이션 번들을 서명하는데 사용되는 "certificate.pem" 및 "key.pk8" 파일이 생성됩니다.
+
+![Signing Android bundle](images/android/sign_bundle2.png)
+
+> 인증서와 키가 안전하게 저장되었는지 확인하십시오. 만약 이 파일들을 잃어버리면 Google Play에 **.apk** 업데이트 버전의 파일을 다신 업로드 할 수 없게 됩니다.
+
+## Troubleshooting
+### 장치가 Targets 메뉴에 나타나지 않을 경우
+장치와 컴퓨터가 동일한 와이파이 네트워크에 있는지 확인합니다. 또한 "dmengine" 앱이 에디터와 동일한 버전인지도 확인합니다. 만약 에디터가 업그레이드 되었다면, "dmengine.apk"도 새로 다운로드해서 장치에 설치해야 합니다.
+
+### 설치시 "Failure [INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES]" 오류가 발생할 경우
+Android는 새 인증서로 앱을 설치하려는 것을 감지합니다. 디버그용 빌드로 번들을 생성할 때, 각 빌드는 임시 인증서로 서명됩니다. 새 버전을 설치하기 전에 기존 앱을 제거 하십시오.
+
+```
+$ adb uninstall com.defold.examples
+Success
+$ adb install Defold\ examples.apk
+4826 KB/s (18774344 bytes in 3.798s)
+    pkg: /data/local/tmp/Defold examples.apk
+Success
+```

docs/ko/manuals/animation.md

@@ -0,0 +1,326 @@
+# Animation
+Defold는 오브젝트 컴포넌트의 그래픽 소스로 사용할 수 있는 다양한 종류의 애니메이션을 지원합니다.
+
+#### Flip-book animation
+플립북 애니메이션은 연속적으로 표시되는 일련의 스틸컷 이미지들로 구성됩니다. 이 기술은 전통적인 셀 에니메이션과 매우 비슷합니다(http://en.wikipedia.org/wiki/Traditional_animation 참고). 이 방식은 각각의 프레임을 개별적으로 조작하므로 무한한 가능성이 있습니다. 하지만 프레임 마다 고유한 이미지로 저장해야 하므로 메모리 공간이 많이 필요할 수 있습니다. 또한 애니메이션을 부드럽게 표현하려면 매 초마다 나타나는 이미지의 수를 늘리는데 의존해야 하므로 그만큼 작업량 또한 증가하게 됩니다. 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](Spine) 문서를 참고 바랍니다.
+
+![](images/animation/spine_animation.png) ![](images/animation/frog_runloop.gif)
+
+#### 3D skinned animation
+3D 모델의 스켈레톤 애니메이션은 스파인 애니메이션과 비슷하지만 2D가 아니라 3D로 동작합니다. 3D 모델은 별도의 파트로 잘리지 않고 컷아웃 애니메이션 처럼 뼈대로 묶입니다. 대신 이 뼈대들은 모델의 버텍스(vertex)에 변형(deformation)을 적용할 수 있으며, 뼈대가 버텍스에 영향을 미치는 정도를 제어할 수 있습니다.
+
+3D 데이터를 애니메이션 모델로 임포트 하는 자세한 방법은 [3D graphics](3D%20graphics) 문서를 참고 바랍니다.
+
+![](images/animation/blender_animation.png) ![](images/animation/wiggle.gif)
+
+#### Property animation
+숫자로 된 모든 속성(숫자, vector3, vector4, 쿼터니온(quaterion))은 내장된 애니메이션 시스템에서 go.animate() 함수를 사용해서 애니메이션 효과를 줄 수 있으며 셋팅한 플레이백 모드(playback mode)나 이징(easing) 함수에 따라 엔진이 자동적으로 속성값들을 트위닝(tween) 합니다. 또한 이징 함수를 커스텀하게 변경할 수도 있습니다.
+
+![](images/animation/property_animation.png) ![](images/animation/bounce.gif)
+
+## Playing flip-book animations
+스프라이트와 GUI 박스 노드는 플립북 애니메이션을 재생할 수 있으며 런타임시 이를 제어할 수 있습니다.
+
+#### Sprites
+스프라이트를 런타임시 애니메이션을 하기 위해서는 play_animation 메세지를 텍스쳐를 애니메이션 하길 원하는 스프라이트 컴포넌트에 보내야 합니다. 애니메이션이 플레이를 끝내자 마자, 엔진은 play_animation 메세지를 보냈던 스크립트로 animation_done 메세지를 돌려 줍니다.
+
+#### GUI box nodes
+GUI 박스 노드를 런타임시 애니메이션을 하기 위해서는 gui.play_flipbook() 함수를 사용해야 합니다. 아래 예제를 살펴보기 바랍니다.
+
+### Sprite example
+당신의 게임에 "dodge"라는 기능이 있다고 가정해 봅시다. 이는 특정 버튼을 누르면 플레이어가 회피 동작을 하게 됩니다. 당신은 4 종류의 애니메이션을 만들어서 시각적인 피드백을 주는 기능을 지원합니다:
+
+#### "idle"
+플레이어 캐릭터가 대기하고 있는 반복 애니메이션.
+#### "dodge_idle"
+A looping animation of the player character idling while being in the dodging stance.
+플레이어 캐릭터가 회피동작을 지속하고 있는 반복 애니메이션.
+#### "start_dodge"
+플레이어 캐릭터가 회피를 시작하는 일회성(play-once)의 과도기(transition) 애니메이션.
+#### "stop_dodge"
+플레이어 캐릭터가 회피를 끝내는 일회성(play-once)의 과도기(transition) 애니메이션.
+
+이 로직은 아래 스크립트 처럼 구현할 수 있습니다:
+
+```lua
+function on_input(self, action_id, action)
+    -- 버튼입력시 "dodge" 동작을 시작함
+    if action_id == hash("dodge") then
+        if action.pressed then
+            msg.post("#sprite", "play_animation", {id = hash("start_dodge")})
+            -- 회피동작 상태인지 기억하기
+            self.dodge = true
+        elseif action.released then
+            msg.post("#sprite", "play_animation", {id = hash("stop_dodge")})
+            -- 회피동작을 끝냄
+            self.dodge = false
+        end
+    end
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("animation_done") then
+        -- 애니메이션의 트랜지션이 끝나고 반복 애니메이션을 시작함
+        if self.dodge then
+            msg.post("#sprite", "play_animation", {id = hash("dodge_idle")})
+        else
+            msg.post("#sprite", "play_animation", {id = hash("idle")})
+        end
+    end
+end
+```
+
+### GUI box node example
+노드의 애니메이션이나 이미지를 선택하는 중에도, 이미지 소스(아틀라스나 타일소스)와 기본 애니메이션을 한방에 할당 할 수 있습니다. 이미지 소스는 노드에 정적으로 셋팅되지만 현재 애니메이션의 플레이를 런타임시에도 변경할 수 있습니다. 스틸컷 이미지들은 한 프레임짜리 애니메이션 처럼 다뤄지므로 런타임시 이미지를 바꾼다는 것은 노드에서 각기 다른 플립북 애니메이션을 플레이 하는것과 완전히 동일합니다:
+
+```lua
+local function flipbook_done(self)
+    msg.post("#", "jump_completed")
+end
+
+function init(self)
+    local character_node = gui.get_node("character")
+    -- 노드가 이 작업을 수행하려면 재생중인 새 애니메이션/이미지와 동일한 아틀라스 또는 타일소스에 기본 애니메이션을 가지고 있어야 합니다.
+    gui.play_flipbook(character_node, "jump_left", flipbook_done)
+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
+    msg.post(url, "play_sound", { gain = message.float })
+  end
+end
+```
+
+## 3D Model animation
+모델은 model.play_anim() 함수를 사용해서 애니메이션 됩니다:
+
+```lua
+function init(self)
+    -- #model에서 앞뒤로 움직이는 "wiggle" 애니메이션 시작
+    model.play_anim("#model", "wiggle", go.PLAYBACK_LOOP_PINGPONG)
+end
+```
+> Defold는 현재 현재 베이크 애니메이션(baked animations)만 지원합니다. 애니메이션은 키프레임마다 각각의 애니메이션 본(animated bone)을 위한 메트릭스를 가져야 하며 위치, 회전, 스케일은 별도의 키로 가지지 말아야 합니다.
+
+> 또한 애니메이션은 선형적으로 보간(linearly interpolated)됩니다. 고급 곡선 보간(curve interpolation)을 하려면 애니메이션을 익스포터(exporter)에서 미리 구워(prebake)야 합니다.
+
+> Collada의 애니메이션 클립(Animation clip)은 지원하지 않습니다. 모델별로 다수의 애니메이션을 사용하기 위해서는 각각 별도의 **.dae** 파일로 익스포트 하고 Defold의 **.animationset** 파일로 합쳐야 합니다.
+
+### The bone hierarchy
+모델 스켈레톤의 뼈대들은 게임 오브젝트에 내부적으로 나타납니다. 모델 컴포넌트의 아웃라인 창(**Outline**)에서 뼈대의 계층구조와 각 뼈대의 이름을 볼 수 있습니다.
+
+![Model hierarchy](images/animation/model_hierarchy.png)
+
+런타임시 뼈대 게임오브젝트의 인스턴스 아이디를 탐색할 수 있습니다. model.get_go() 함수는 특정 뼈대의 아이디를 반환합니다.
+
+```lua
+-- wiggler 모델의 중간 뼈를 가져옴
+local bone_go = model.get_go("#wiggler", "Bone_002")
+
+-- 이제 게임 오브젝트로 뭔가 유용한 작업을 해볼까나...
+```
+
+### Cursor animation
+스파인 모델과 마찬가지로, 3D 모델은 "cursor" 속성을 조작해서 애니메이션을 처리할 수 있습니다:
+
+```lua
+-- #model에 애니메이션을 설정하고 재생은 아직 안함
+model.play_anim("#model", "wiggle", go.PLAYBACK_NONE)
+-- 애니메이션의 시작점으로 커서를 셋팅함
+go.set("#model", "cursor", 0)
+-- 0과 1 사이로 커서를 트위닝(Tween)함
+go.animate("#model", "cursor", go.PLAYBACK_LOOP_PINGPONG, 1, go.EASING_INOUTQUAD, 3)
+```
+
+## Property animation
+게임 오브젝트나 컴포넌트의 속성값을 애니메이션 처리하기 위해서는 go.animate() 함수를 사용해야 합니다. GUI 노드 속성을 위해서는 gui.animate() 를 사용하면 됩니다.
+
+```lua
+-- 컴포넌트의 position의 y 속성값을 200으로 설정
+go.set(".", "position.y", 200)
+-- 그리고 애니메이션 시킴
+go.animate(".", "position.y", go.PLAYBACK_LOOP_PINGPONG, 100, go.EASING_OUTBOUNCE, 2)
+```
+
+주어진 속성의 모든 애니메이션을 중지하려면, go.cancel_animations() 를 호출하거나 GUI 노드에서는 gui.cancel_animation()를 호출하면 됩니다:
+
+```lua
+-- 현재 게임오브젝트에서 오일러(euler) z축의 회전 애니메이션을 중지함
+go.cancel_animation(".", "euler.z")
+```
+
+만약 "position"과 같이 복합적인(composite) 속성의 애니메이션을 취소하면, 하위 요소들("position.x", "position.y", "position.z")의 애니메이션도 함께 취소됩니다.
+
+[Properties](Properties) 매뉴얼에 게임 오브젝트, 컴포넌트, GUI노드의 모든 속성들에 대한 설명이 있습니다.
+
+### GUI node property animation
+대부분의 모든 GUI 노드 속성들은 애니메이션 가능합니다. 예를 들어, "color" 속성을 설정해서 투명값을 조절하여 노드를 보이지 않게 만든 후에, 색상을 하얗게(tint 컬러가 아님) 애니메이션 처리해서 페이드인 효과를 줄 수 있습니다. 
+
+```lua
+local node = gui.get_node("button")
+local color = gui.get_color(node)
+-- 색상을 하얗게 애니메이션 처리하기
+gui.animate(node, gui.PROP_COLOR, vmath.vector4(1, 1, 1, 1), gui.EASING_INOUTQUAD, 0.5)
+-- 외곽을 붉은색으로 애니메이션 처리하기
+gui.animate(node, "outline.x", 1, gui.EASING_INOUTQUAD, 0.5)
+-- 그리고 x좌표를 100으로 이동시키기
+gui.animate(node, hash("position.x"), 100, gui.EASING_INOUTQUAD, 0.5)
+```
+
+## Playback Modes
+애니메이션은 한 번 또는 반복적으로 재생될 수 있습니다. 애니메이션 재생 방법은 플레이백 모드(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
+
+핑퐁(pingpong) 모드는 애니메이션을 처음엔 정방향으로 재생하고, 다음엔 역방향으로 재생합니다. GUI 속성을 애니메이션 하기 위한 모드는 아래와 같습니다:
+
+* 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
+
+## Easing
+이징(easing)은 애니메이션 값이 시간에 따라 어떻게 변화하는지를 정의합니다. 아래 이미지들은 이징의 종류별로 시간에 따른 변화를 그래프로 설명하고 있습니다.
+
+go.animate() 를 호출할 때 사용하는 적당한 값은 go.EASING_LINEAR, go.EASING_INBACK, go.EASING_OUTBACK 등이 있습니다.
+
+gui.animate() 를 호출할 때  사용하는 값은 gui.EASING_LINEAR, gui.EASING_INBACK, gui.EASING_OUTBACK 등입니다.
+
+![](images/properties/easing_linear.png) ![](images/properties/easing_inback.png) ![](images/properties/easing_outback.png) ![](images/properties/easing_inoutback.png) ![](images/properties/easing_outinback.png) ![](images/properties/easing_inbounce.png) ![](images/properties/easing_outbounce.png) ![](images/properties/easing_inoutbounce.png) ![](images/properties/easing_outinbounce.png) ![](images/properties/easing_inelastic.png) ![](images/properties/easing_outelastic.png) ![](images/properties/easing_inoutelastic.png) ![](images/properties/easing_outinelastic.png) ![](images/properties/easing_insine.png) ![](images/properties/easing_outsine.png) ![](images/properties/easing_inoutsine.png) ![](images/properties/easing_outinsine.png) ![](images/properties/easing_inexpo.png) ![](images/properties/easing_outexpo.png) ![](images/properties/easing_inoutexpo.png) ![](images/properties/easing_outinexpo.png) ![](images/properties/easing_incirc.png) ![](images/properties/easing_outcirc.png) ![](images/properties/easing_inoutcirc.png) ![](images/properties/easing_outincirc.png) ![](images/properties/easing_inquad.png) ![](images/properties/easing_outquad.png) ![](images/properties/easing_inoutquad.png) ![](images/properties/easing_outinquad.png) ![](images/properties/easing_incubic.png) ![](images/properties/easing_outcubic.png) ![](images/properties/easing_inoutcubic.png) ![](images/properties/easing_outincubic.png) ![](images/properties/easing_inquart.png) ![](images/properties/easing_outquart.png) ![](images/properties/easing_inoutquart.png) ![](images/properties/easing_outinquart.png) ![](images/properties/easing_inquint.png) ![](images/properties/easing_outquint.png) ![](images/properties/easing_inoutquint.png) ![](images/properties/easing_outinquint.png)
+
+### Custom easing
+값의 모음(set of values)으로 벡터(vector)를 정의해서 위에서 미리 정의된 이징 상수(easing constants) 대신에 이징 커브(easing curve)를 커스텀하게 만들 수 있습니다:
+
+```lua
+local values = { 0, 0, 0, 0, 0, 0, 0, 0,
+                 1, 1, 1, 1, 1, 1, 1, 1,
+                 0, 0, 0, 0, 0, 0, 0, 0,
+                 1, 1, 1, 1, 1, 1, 1, 1,
+                 0, 0, 0, 0, 0, 0, 0, 0,
+                 1, 1, 1, 1, 1, 1, 1, 1,
+                 0, 0, 0, 0, 0, 0, 0, 0,
+                 1, 1, 1, 1, 1, 1, 1, 1 }
+local square_easing = vmath.vector(values)
+go.animate("go", "position.y", go.PLAYBACK_LOOP_PINGPONG, 100, square_easing, 2.0)
+```
+
+## 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()로 수동적으로 취소 되었을 경우엔 호출되지 않습니다. 콜백은 애니메이션 완료시 이벤트를 트리거하거나 여러 애니메이션을 함께 연결하는데 사용됩니다.
+
+콜백의 정확한 함수 형태(signature)는 애니메이션 함수마다 조금씩 다릅니다. 자세한 것은 API 문서를 참고 바랍니다.
+
+```lua
+local function done_bouncing(self, url, property)
+    -- 애니메이션을 끝냈다.. 이제 뭔가 해보자...
+end
+
+function init(self)
+    go.animate(".", "position.y", go.PLAYBACK_ONCE_FORWARD, 100, go.EASING_OUTBOUNCE, 2, 0, done_bouncing)
+end
+```

docs/ko/manuals/application-lifecycle.md

@@ -0,0 +1,106 @@
+#Application lifecycle
+이 문서는 Defold의 게임과 어플리케이션의 라이프사이클에 대해 자세히 알아봅니다.
+
+Defold의 어플리케이션이나 게임의 라이프사이클은 매우 단순합니다. 엔진은 초기화(initialization), 업데이트 루프(update loop: 여기서 대부분의 시간이 소비됨), 마무리(finalization) 세 단계로 진행합니다.
+
+![Lifecycle overview](images/application_lifecycle/application_lifecycle_overview.png)
+
+대부분의 경우엔 Defold 내부 동작의 기본적인 이해만 해도 되지만, 이 작업의 정확한 순서를 이해하지 못하면 난관에 빠질 수도 있습니다. 이 문서는 게임엔진이 어떻게 어플리케이션을 시작부터 끝까지 실행하는지 설명합니다
+
+어플리케이션은 엔진을 실행하는데 필요한 모든 것을 초기화(initialization)하면서 시작합니다. main 컬렉션을 로드하고 init() Lua 함수가 존재하는 로드된 모든 컴포넌트(스크립트 컴포넌트나 GUI스크립트가 있는 GUI 컴포넌트)들의 init() 함수를 호출합니다. 이를 통해 커스텀하게 초기화를 할 수 있습니다.
+
+다음으로 어플리케이션은 업데이트 루프(update loop)에 진입해서 어플리케이션 생명주기 대부분을 머물게 됩니다. 매 프레임마다, 추가된 게임 오브젝트와 컴포넌트들이 업데이트 되며 스크립트나 GUI 스크립트에서는 update() 함수가 호출됩니다. 업데이트가 반복되는 동안 메세지는 수신자 측에 발송되며, 사운드를 플레이하고 그래픽을 렌더링 합니다.
+
+어플리케이션 라이프사이클을 종료해야 하는 특정 시점에서는 어플리케이션을 종료하기 직전에 엔진은 업데이트 루프 단계를 빠져나와 마무리(finalization) 단계로 진입합니다. 여기서 로드된 모든 게임 오브젝트의 삭제를 준비하게 됩니다. 모든 오브젝트 컴포넌트의 final() 함수가 호출되므로 여기서 커스텀한 리소스 해제 작업을 할 수 있습니다. 모든 오브젝트가 삭제된 후 main 컬렉션도 언로드 됩니다.
+
+## Initialization
+
+![Lifecycle overview](images/application_lifecycle/application_lifecycle_init.png)
+
+이 다이어그램은 초기화 단계를 더 자세히 설명하고 있습니다. 이 단계의 더 정확한 설명을 위해 라이프 사이클과 관련이 있는 "dispatch messages" 단계("spawn dynamic objects"단계 바로 직전에 호출됨)에 대한 자세한 설명을 오른쪽 블록에 배치했습니다.
+
+사실, main컬렉션이 로드되기 전 초기화 동안 엔진이 내부적으로 수행하는 단계는 훨씬 많습니다. 메모리 프로파일러, 소켓, 그래픽, HID(인풋 디바이스), 사운드, 물리 등등의 많은 것들을 설정하고 "game.project" 같은 어플리케이션 설정값을 또한 로드 후 처리하는 작업을 수행합니다.
+
+엔진의 초기화가 끝난 후 사용자가 맨처음으로 직접 제어할 수 있는 진입점은 렌더 스크립트의 init() 함수입니다.
+
+main 컬렉션이 로드되고 초기화 되면 컬렉션의 모든 게임 오브젝트는 자신의 transform 정보(위치(position), 이동(movement), 회전(rotation), 확대축소(scaling))를 자식들에게 반영합니다. 컴포넌트에 init() 함수가 있다면 호출됩니다.
+
+> 게임오브젝트 컴포넌트의 init() 함수가 호출되는 순서는 정해진 것이 없으므로 게임엔진이 동일한 컬렉션에 속한 오브젝트들을 특정한 순서로 초기화 할거라고 미리 예측하여 개발하지 않는 것이 좋습니다.
+
+init() 함수 이후에는 새 메세지를 보낼 수도 있고, 팩토리가 새 오브젝트를 스폰되게 할 수도 있고, 삭제하려는 오브젝트에 마킹 작업을 하기도 하고 엔진이 다음 "post-update" 단계를 수행하기 위해 정리 작업을 할 수도 있습니다.  여기서는 메세지를 디스패치하고 팩토리를 사용하여 게임 오브젝트를 스폰하고 오브젝트를 삭제하는 작업을 합니다.
+
+post-update 단계에는 메세지 큐를 보낼 뿐만아니라 또한 메세지가 컬렉션 프록시로 전송되는 일을 다루는 "dispatch messages" 단계를 포함하고 있다는 것을 알아두기 바랍니다. 이 단계가 수행되는 동안은 proxy를 통하여(활성화, 비활성화, 로딩, 언로딩을 위한 마킹작업 등) 하위 작업들이 업데이트 됩니다.
+
+위의 다이어그램을 살펴보면, init() 하는 동안에 [컬렉션 프록시(Collection proxy)](Collection%20proxy)를 로드하고 프록시의 모든 오브젝트들을 초기화하고 프록시의 컬렉션을 언로드하는 것이 가능하다는 것을 알 수 있습니다. 이 모든 것이 컴포넌트의 update()가 처음 호출되기 이전에 발생합니다. 즉 엔진이 모든 초기화(initialization) 단계를 빠져나가서 업데이트 반복(update loop) 단계로 진입하기 이전입니다:
+
+```lua
+function init(self)
+        print("init()")
+        msg.post("#collectionproxy", "load")
+end
+
+function update(self, dt)
+    -- 이 코드까지 도달하기 전에 프록시 컬렉션이 언로드됨
+    print("update()")
+end
+
+function on_message(self, message_id, message, sender)
+        if message_id == hash("proxy_loaded") then
+                print("proxy_loaded. Init, enable and then unload.")
+                msg.post("#collectionproxy", "init")
+                msg.post("#collectionproxy", "enable")
+                msg.post("#collectionproxy", "unload")
+                -- 이 오브젝트의 update()가 호출되기 이전에
+                -- 프록시컬렉션의 init()과 final()이 호출됨
+          end
+end
+```
+
+## The update loop
+업데이트 루프는 매 프레임 마다 한 번씩 긴 시퀀스로 실행됩니다. 명확한 이해를 위해 아래 그림에선 이 업데이트 시퀀스를 논리적인 시퀀스 블록으로 구분했습니다. 또한 "Dispatch messages" 블록도 같은 이유로 분리해서 보여줍니다:
+
+![Update loop](images/application_lifecycle/application_lifecycle_update.png)
+
+#### Input
+입력(input)은 사용 가능한 디바이스로부터 읽혀지며, [인풋 바인딩(input binding)](Input)에 대해 매핑되어 디스패치 됩니다. 입력 포커스를 획득한 게임 오브젝트는 사용자의 입력을 받아 on_input() 함수가 있는 모든 컴포넌트에게 전송합니다. 스크립트 컴포넌트와 GUI스크립트가 있는 GUI컴포넌트를 사용하는 게임 오브젝트가 입력을 받아 이들 컴포넌트의 on_input() 함수로 보냅니다.
+
+입력 포커스를 획득하고 컬렉션 프록시 컴포넌트를 포함하고 있는 게임오브젝트는 프록시 컬렉션에 있는 컴포넌트들에게 까지 입력을 전달합니다. 이 프로세스는 활성화된 컬렉션 프록시들을 따라 재귀적으로 반복되어 전달됩니다.
+
+#### Update
+main 컬렉션의 각 게임 오브젝트 컴포넌트 순환하며 수행됩니다. 만약 컴포넌트의 스크립트에 update()함수를 선언했다면 이 함수를 호출해 줍니다. 또한 컴포넌트가 컬렉션 프록시라면 이 프록시의 컬렉션 안에 있는 각 컴포넌트는 재귀적으로 업데이트 되어 위 다이어그램의 "update" 시퀀스의 모든 단계를 수행합니다.
+
+> 게임오브젝트 컴포넌트의 update() 함수가 호출되는 순서는 정해진 것이 없으므로 게임엔진이 동일한 컬렉션에 속한 오브젝트들을 특정한 순서로 초기화 할거라고 미리 예측하여 개발하지 않는 것이 좋습니다.
+
+다음 단계에선 게시된 모든 메세지가 전달(dispatch)됩니다. 수신 컴포넌트의 on_message() 코드는 추가적인 메세지를 게시할 수 있으므로 메세지 전달자(message dispatcher)는 메세지 큐가 다 비워질 때 까지 게시된 메세지를 전달하는 작업을 지속합니다. 그러나 메세지 전달자가 수행 가능한 횟수에는 성능상 한계가 있습니다. [메세지 전달(Message passing)](Message%20passing) 문서의 "Advanced topics" 섹션을 참고 바랍니다.
+
+충돌(collision) 오브젝트 컴포넌트의 경우엔, 물리 메세지(collisions, triggers, ray_cast 등을 처리함)가 게임오브젝트가 영향을 주는 주변 오브젝트의 스크립트에 쓰인 on_message() 함수로 전달됩니다.
+
+다음으로는 게임 오브젝트의 이동, 회전, 확대/축소 작업을 각기 컴포넌트와 자식 게임 오브젝트의 컴포넌트 들에게 반영시키는 것으로 변형(transform)을 완료합니다.
+
+#### Render update
+렌더 업데이트 블록은 메세지들을 @render 소켓(오브젝트 URL의 socket, 네트워크 소켓 아님)으로 전달합니다(카메라 컴포넌트의 "set_view_projection" 메세지나 "set_clear_color" 메세지 등). 다음으로는 렌더 스크립트의 update() 함수가 호출됩니다.
+
+#### Post update
+업데이트 작업 후엔, 포스트 업데이트(post update) 시퀀스가 실행됩니다. 여기선 언로드를 위해 예약된 컬렉션 프록시의 메모리를 언로드합니다(이는 "dispatch messages" 시퀀스 수행 중에도 발생함). 삭제가 예약된 게임 오브젝트는 모든 소속 컴포넌트들의 final() 함수를 호출합니다. final()함수의 코드에서 메세지큐로 새 메세지를 보내는 경우엔 "dispatch messages"가 이를 나중에 처리하게 됩니다.
+
+다음으로는 게임오브젝트를 스폰하도록 지시받은 팩토리 컴포넌트가 작업을 시작하고, 마지막으로는 삭제가 예약된 게임오브젝트들이 실제로 삭제 됩니다.
+
+업데이트 루프의 마지막 단계는 @system 메세지("exit", "reboot" 메세지, 프로파일러 토글하기, 비디오 캡쳐를 시작하거나 멈추기 등등)를 전달하는 것을 포함하고 있습니다. 다음으로 그래픽을 렌더링합니다. 그래픽이 렌더링 되는 동안, 비디오 캡쳐 작업과 비주얼 프로필러(visual profiler)의 렌더링 작업도 수행됩니다. ( [Debugging](Debugging) 문서를 참고 바랍니다.)
+
+#### Frame rate and collection time step
+초당 프레임 업데이트의 수(FPS, 즉 update-loop의 실행 수와 동일함)는 프로젝트 설정(project settings)에서 셋팅할 수 있으며 프로그래밍 방식으로 @system 소켓에 "set_update_frequency" 메세지를 보내서 셋팅할 수도 있습니다. 그리고 프록시로 "set_time_step" 메세지를 보내서 컬렉션 프록시의 시간 흐름(time step)을 개별적으로 설정하는 것도 가능합니다. 컬렉션의 시간 흐름을 변경해도 프레임 레이트에 영향을 주지는 않습니다. 대신, 물리 업데이트(physics update)의 시간 흐름과, update() 함수로 전달되는 "dt" 인자값에 영향을 줍니다. 또한, 시간 흐름을 변경하는 것은 각 프레임에 호출되는 update()의 횟수를 변경하는 것은 아닙니다. update()는 프레임당 한번씩만 호출됩니다.
+
+(자세한 것은 [Collection proxy](Collection%20proxy) 와 [set_time_step](set_time_step) 를 참고하세요.)
+
+## Finalization
+어플리케이션이 종료되는 시점에는, 마지막 업데이트 루프 시퀀스를 끝내고, 컬렉션 프록시들을 언로드하여 프록시 컬렉션의 모든 게임오브젝트의 마무리(finalizing)와 삭제(deleting)를 수행합니다.
+
+엔진은 마지막으로 main 컬렉션과 오브젝트들을 다루기 위한 마무리(finalization) 시퀀스에 진입합니다.
+
+![Finalization](images/application_lifecycle/application_lifecycle_final.png)
+
+먼저 컴포넌트의 final() 함수를 호출한 후, 남은 메세지들을 전달합니다. 마지막으로, 모든 게임 오브젝트가 삭제되고 main 컬렉션이 언로드 됩니다.
+
+다음으로 엔진은 서브시스템을 종료하고, 프로젝트 설정을 삭제하고, 메모리 프로파일러를 종료하는 등의 작업을 백그라운드에서 수행합니다.
+
+이제 어플리케이션은 완전히 종료되었습니다.

docs/ko/manuals/bob.md

@@ -0,0 +1,103 @@
+# Bob the builder
+Bob은 에디터 외부에서 Defold 프로젝트를 빌드하기 위한 도구입니다. 이 메뉴얼은 이 도구를 사용하는 방법에 대해 설명합니다.
+
+## Overview
+Bob은 데이터를 빌드(에디터에서  **Project ▸ Build And Launch** 선택하는 것에 해당함)하고 압축하고 독립(standalone) 및 배포 가능한 어플리케이션 번들을 생성(에디터에서 **Project ▸ Bundle ▸ \*** 을 선택하는 것에 해당함)할 수 있습니다.
+
+Bob은 빌드에 필요한 모든 것을 포함하는 Java JAR 파일 형식으로 배포됩니다. http://d.defold.com 에서 최신 "bob.jar" 배포본을 찾을 수 있습니다. 원하는 Releases 버전을 선택해서 "bob/bob.jar" 파일을 다운로드 합니다. Bob 도구를 실행하려면 컴퓨터에 Java 8 이 설치되어야 합니다. Javas는 https://www.java.com 에서 다운로드 할 수 있습니다.
+
+## Usage
+Bob은 쉘이나 커맨드 라인에서 "java"(또는 Windows에서는 "java.exe") 호출시 bob java 파일을 인수로 넘겨서 실행할 수 있습니다.
+
+```
+$ java -jar bob.jar --help
+usage: bob [options] [commands]
+ -,--identity <arg>                  Sign identity (iOS)
+ -a,--archive                        Build archive
+ -bo,--bundle-output <arg>           Bundle output directory
+ -br,--build-report <arg>            Filepath where to save a build report
+                                     as JSON
+ -brhtml,--build-report-html <arg>   Filepath where to save a build report
+                                     as HTML
+ -ce,--certificate <arg>             Certificate (Android)
+ -d,--debug                          Use debug version of dmengine (when
+                                     bundling)
+ -e,--email <arg>                    User email
+ -h,--help                           This help message
+ -i,--input <arg>                    Source directory. Default is current
+                                     directory
+ -k,--keep-unused                    Keep unused resources in archived
+                                     output
+ -mp,--mobileprovisioning <arg>      mobileprovisioning profile (iOS)
+ -o,--output <arg>                   Output directory. Default is
+                                     "build/default"
+ -p,--platform <arg>                 Platform (when bundling)
+ -pk,--private-key <arg>             Private key (Android)
+ -r,--root <arg>                     Build root directory. Default is
+                                     current directory
+ -tp,--texture-profiles <arg>        Use texture profiles
+ -u,--auth <arg>                     User auth token
+ -v,--verbose                        Verbose output
+```
+
+### Available commands:
+
+#### clean
+빌드 디렉토리에서 빌드된 파일들을 삭제합니다.
+#### distclean
+빌드 디렉토리에서 모든 파일들을 삭제합니다.
+#### build
+모든 프로젝트 데이터를 빌드합니다. "--archive" 옵션을 추가해서 압축 파일(빌드 디렉토리의 "game.darc")로 빌드할 수 있습니다.
+#### bundle
+특정 플랫폼의 어플리케이션 번들을 생성합니다. 번들 작업을 하려면 빌드된 압축 파일("build"에서 "--archive" 옵션을 사용해서)이 있어야 하며 타겟 플랫폼을 지정("--platform" 옵션을 사용해서)해야 합니다. Bob은 "--bundle-output" 옵션을 사용하여 지정된 출력 디렉토리에서 번들을 생성할 수 있습니다. 이 번들은 "game.project"의 프로젝트 이름 설정값에 따라 이름이 정해집니다.
+#### resolve
+모든 외부 라이브러리 종속성을 처리합니다.
+
+### Available platforms:
+
+#### x86-darwin
+Mac OSX
+#### x86_64-darwin
+Mac OSX 64 bit
+#### x86-win32
+Windows
+#### x86-linux
+Linux
+#### armv7-darwin
+iOS
+#### armv7-android
+Android
+#### js-web
+HTML5
+
+기본적으로 Bob은 현재 디렉토리에서 빌드할 프로젝트를 찾습니다. 만약 현재 디렉토리를 Defold 프로젝트로 변경하고 bob을 호출하면, 기본 출력 디렉토리인 "build/default" 에서 프로젝트를 빌드합니다.
+
+```
+$ cd /Applications/Defold-beta/branches/14/4/main
+$ java -jar bob.jar
+100%
+$
+```
+
+한방에 일련의 작업들을 수행하려면 명령들을 함께 나열하면 됩니다. 아래 예제는 라이브러리 종속성을 처리하고, 빌드 디렉토리를 지우고, 번들과 데이터를 OSX용 어플리케이션(이름은 "My Game.app")으로 빌드합니다.
+
+```
+$ java -jar bob.jar --archive --platform x86-darwin resolve distclean build bundle
+100%
+$ ls -al build/default/
+total 70784
+drwxr-xr-x   13 sicher  staff       442  1 Dec 10:15 .
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 ..
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 My Game.app
+drwxr-xr-x    8 sicher  staff       272  1 Dec 10:15 builtins
+-rw-r--r--    1 sicher  staff    140459  1 Dec 10:15 digest_cache
+drwxr-xr-x    4 sicher  staff       136  1 Dec 10:15 fonts
+-rw-r--r--    1 sicher  staff  35956340  1 Dec 10:15 game.darc
+-rw-r--r--    1 sicher  staff       735  1 Dec 10:15 game.projectc
+drwxr-xr-x  223 sicher  staff      7582  1 Dec 10:15 graphics
+drwxr-xr-x    3 sicher  staff       102  1 Dec 10:15 input
+drwxr-xr-x   20 sicher  staff       680  1 Dec 10:15 logic
+drwxr-xr-x   27 sicher  staff       918  1 Dec 10:15 sound
+-rw-r--r--    1 sicher  staff    131926  1 Dec 10:15 state
+$
+```

docs/ko/manuals/building-blocks.md

@@ -0,0 +1,178 @@
+# Building blocks
+이 문서에서는 *게임오브젝트, 컴포넌트, 컬렉션*이 어떻게 동작하는지 자세히 설명합니다.
+
+Defold에서 만든 것 중 일부는 다른 소프트웨어와는 다르게 설계되어 있습니다. 이 블록들을 왜 합치며 어떻게 합치는지에 대한 이해가 조금 어려울 수도 있습니다. Defold가 어떻게 게임 리소스를 관리하고 접근하는지 이해하기 위해서는, 이 문서와 [Message passing](Message%20passing) 문서를 참고 바랍니다. 여기에 있는 것들 중 일부 혹은 대부분은 생소하고 처음에는 이해하기 힘들겠지만, 걱정 마세요. 시간을 내서 에디터와 게임엔진을 다뤄보고 실행에 문제가 생기면 문서들을 둘러 보시기 바랍니다.
+
+![Building blocks](images/building_blocks/building_blocks.png)
+
+## Game objects
+게임 오브젝트는 게임이 실행되는 동안에 각각의 수명을 가지는 간단한 객체입니다. 일반적으로 게임 오브젝트는 비주얼이나 오디오를 나타내는 요소들(예를 들어 스프라이트 컴포넌트나 사운드 컴포넌트)을 장착하여 사용됩니다.  또한 스크립트 컴포넌트를 장착해서 특정한 동작을 구현할 수도 있습니다. 따라서 게임 오브젝트는 이런 다양한 컴포넌트들을 위한 컨테이너라는 점에서 스프라이트, 모델, 사운드와는 구분됩니다. 당신은 게임 오브젝트를 생성하여 에디터상의 컬렉션에 배치시킬 수 있으며 혹은 팩토리를 사용하여 런타임시 동적으로 스폰되게 할 수도 있습니다.
+
+여기 에디터에서 게임 오브젝트를 생성하는 두 가지 방법이 있습니다:
+
+1. 게임오브젝트 파일을 만든 후 컬렉션에 이 파일의 인스턴스를 만들기
+2. 게임오브젝트의 인스턴스를 컬렉션에 배치하여 만들기
+
+이들 방식의 차이점을 살펴 보도록 합시다.
+
+#### Prototypes and instances
+게임 오브젝트 파일을 생성해서 게임 오브젝트를 위한 설계도(blueprint)나 프로토타입(prototype)을 만듭니다. 나중에 이 프로토타입으로 하나 혹은 다수의 게임오브젝트 인스턴스를 생성할 수 있습니다.
+
+![Game object file](images/building_blocks/building_blocks_gameobject_file.png)
+
+게임 오브젝트 파일을 만들어도 게임 실행시에는 아무것도 추가되는 것이 없습니다. 이 게임 오브젝트는 아직 존재하지 않으며, 실제 오브젝트를 만들 수 있는 공식만 존재할 뿐입니다. 미리 만들어 놓은 설계도를 기반으로 실제 게임 오브젝트를 만들기 위해서는, 컬렉션을 오른쪽 클릭하고 **Add Game Object File**을 선택해서 프로젝트의 컬렉션에 게임오브젝트의 인스턴스를 추가하면 됩니다.
+
+![Game object instance](images/building_blocks/building_blocks_gameobject_instance.png)
+
+이제 게임 오브젝트는 작동을 시작할 수 있습니다. 당신은 많은 수의 인스턴스를 만들 수도 있는데, 각각의 인스턴스는 아까 게임 오브젝트 파일에 저장된 것과 똑같은 복제본입니다.
+
+![Game object clones](images/building_blocks/building_blocks_gameobject_clones.png)
+
+이러한 방식의 좋은 점은 게임 오브젝트 파일을 변경하여 프로토타입을 바꾸는 경우, 이 파일을 기반으로 생성된 인스턴스들도 즉시 변경된다는 것입니다.
+
+![Game object alter file](images/building_blocks/building_blocks_gameobject_alter.png)
+
+#### Childing game objects
+이제는 처음으로 특이하게 보이는 사례를 살펴 보도록 합시다. 위의 프로토타입 파일의 "my_gameobject" 인스턴스를 컬렉션에 추가하고, "heart"라는 이름의 게임 오브젝트를 몇몇 컴포넌트들과 함께 생성해 봅시다. (컬렉션에 오른쪽클릭 후 **Add Game Object** 선택) 마지막으로, "heart" 오브젝트를 "my_gameobject"로 드래그해서 자식 오브젝트로 만듭니다.  이제 컬렉션이 다음과 같이 수정되었습니다:
+
+![Game object instance with child](images/building_blocks/building_blocks_gameobject_instance_child.png)
+
+"heart" 오브젝트를 "my_gameobject"로 드래그하는 것으로 인해 "my_gameobject.go"파일이 바뀌는 것이 아닌지 생각할 수도 있지만, 그런 일은 발생하지 않습니다. 이 작업의 영향은 오직 "my_gameobject"라는 게임 오브젝트 인스턴스가 자식 오브젝트를 가지는 것 뿐입니다. 이 게임 오브젝트 인스턴스는 프로토타입과 자식오브젝트에 관한 두 가지 다른 속성을 가집니다. 게임 오브젝트 인스턴스에 자식 오브젝트들을 추가하면 프로토타입은 건드리지 않은 채로 해당 오브젝트의 **자식 속성(children property)** 이 추가됩니다.
+
+컬렉션 파일에 마우스 오른쪽 버튼을 누르고 **Open With > Text Editor**를 선택해서 텍스트 에디터로 컬렉션을 열어 보면 게임 오브젝트 데이터 구조를 파악할 수 있습니다:
+```json
+name: "default"
+instances {
+  id: "my_gameobject"
+  prototype: "/a_simple_test/my_gameobject.go"
+  children: "heart"
+  ...
+}
+scale_along_z: 0
+embedded_instances {
+  id: "heart"
+  data: "embedded_components {\n  id: \"sprite\"\n  type: \"sprite\"\n  data: \"tile_set: \\\"/cards_example/cards_sprites.atlas\\\"\\ndefault_animation: \\\"heart\\\"\\nmaterial: \\\"/builtins/materials/sprite.material\\\"\\nblend_mode: BLEND_MODE_ALPHA\\n\"\n  position {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n  }\n  rotation {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n    w: 1.0\n  }\n}\n"
+  ...
+}
+```
+
+이처럼 게임 오브젝트 인스턴스가 **prototype** 속성을 가지고 있는 것을 위 파일에서 명확히 볼 수 있습니다. 또 다른 속성인 **children**은 "heart"라는 이름의 자식 인스턴스를 가지고 있는데, "heart"는 다른 게임오브젝트와 달리 프로토타입 기반이 아니고 내부에 위치된 게임 오브젝트(in-place game object)이므로 **embedded_instances** 아래에 나열되며 이 데이터는 현재의 컬렉션 파일에만 저장됩니다.
+
+> 이 에디터에서 작업할 때 게임 오브젝트 프로토타입과 인스턴스를 명확하게 구분하는 것 외에도, 런타임시 고정된 아이디로 어떻게 게임 오브젝트를 식별하는지와 자식오브젝트를 설정하는 것이 아이디에 어떻게 영향을 끼치는지 시간을 들여 신중히 공부하는 것이 좋습니다. [Message passing](Message%20passing) 문서에 자세한 설명이 있습니다.
+
+지금쯤 당신은 아마 "게임 오브젝트 파일을 만들어 게임 오브젝트와 자식 오브젝트를 생성한 다음 컬렉션에 이 오브젝트를 인스턴스화 시킨 후 자식 오브젝트를 삭제하면 어떻게 될까?"라는 의문을 품을 수도 있습니다. 간단히 답변하자면 이것은 불가능합니다. 게임 오브젝트 파일은 단일 게임 오브젝트의 설계도면입니다. 오직 빌드시에 에디터에서 컬렉션을 수정하거나 런타임시에 msg.post("my_object", "set_parent", { parent_id = go.get_id("my_parent") }) 를 사용하여 게임 오브젝트의 인스턴스에 자식 오브젝트들을 추가하는 것만 가능합니다.
+
+## Components
+컴포넌트는 특정한 표현이나 기능을 게임 오브젝트에 부여하는데 사용됩니다. 이것들은 게임 오브젝트 안에 포함되어야만 하며 스스로 살아가지 못합니다. 여기에 에디터에서 새 컴포넌트를 생성하는 두가지 방법이 있습니다:
+
+1. 컴포넌트 파일을 생성한 후 컴포넌트의 인스턴스를 게임 오브젝트 안에 만드는 방법
+2. 게임 오브젝트 안에 내장(in-place) 컴포넌트 인스턴스를 만드는 방법
+
+위 두 가지 케이스로 특정 유형의 컴포넌트를 생성해서 에디터에서 이 컴포넌트를 열면 컴포넌트의 종류에 맞는 적합한 에디터를 띄워서 컴포넌트를 다룰 수 있게 해 줍니다.
+
+우리는 이전 섹션에서 **embedded_components** 속성을 통해서 에디터가 내장 컴포넌트를 게임 오브젝트에 어떻게 저장하는지 살펴보았습니다. 이와는 조금 다르지만 파일의 참조(reference)로부터 컴포넌트를 인스턴스화 하면 아래 처럼 나타납니다:
+
+```json
+embedded_instances {
+  id: "heart2"
+  data: "components {\n  id: \"sprite\"\n  component: \"/a_simple_test/my_heart.sprite\"\n  position {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n  }\n  rotation {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n    w: 1.0\n  }\n}\n"
+  ...
+}
+```
+
+컴포넌트의 특정한 데이터는 **component** 속성값을 통해 컴포넌트 파일을 참조하여 저장됩니다.
+
+아마도 가장 자주 쓰이는 컴포넌트 타입은  동작(behaviors)을 구현하는데 쓰이는 스크립트 컴포넌트 일 것입니다.  여기서 잊기 쉬운것은 스크립트 컴포넌트와 이를 포함하는 게임오브젝트간에 명확한 경계가 있다는 사실입니다. 예를 들어, 아래는 일반적인 스타일의 메세지 전달 방법입니다:
+
+```lua
+msg.post("my_object", "my_message", { my_data = 1 }})
+```
+
+여기서 이 커스텀 메세지는 "my_object"라는 게임 오브젝트로 전송됩니다. 이것은 일반적으로 잘 동작하지만 권장하는 방식은 아닙니다. 첫째, 게임 오브젝트로 전송된 메세지는 게임 오브젝트에 포함된 모든 컴포넌트들에게 브로드캐스팅 되어 불필요한 오버헤드가 생길 수 있습니다. 둘째, 게임 오브젝트의 일부 동작을 깨트릴수도 있습니다. 예를 들어, 게임 오브젝트가 여러 개의 스크립트 컴포넌트를 가지고 있고 동시에 처리할 수 있도록 설계되지 않은 채로 이 스크립트가 전부 "my_message"라는 메세지를 기다리고 있다고 가정해 봅시다. 메세지의 주소를 지정하는데 권장하는 방법으로는 가능한 구체적이고 게임 오브젝트와 컴포넌트간 차이를 알기 쉽게 지정하는 것이 좋은 방법입니다.
+
+```lua
+msg.post("my_object#script", "my_message", { my_data = 1 })
+```
+
+#### Custom component properties
+컴포넌트는 한가지 또는 다른 방법으로 컴포넌트를 변경하도록 셋팅된 유형별 특정 속성들이 있습니다. 스프라이트 컴포넌트에는 넓이(width)와 길이(height)가 있으며, 사운드 컴포넌트에는 사운드를 반복할지 여부를 결정하는 속성이 있습니다. 또 스크립트 컴포넌트에서는 특정한 속성을 직접 만들 수도 있습니다. 스크립트 파일에 속성을 만드는 코드를 추가하면 스크립트 컴포넌트의 속성을 쉽게 정의할 수 있습니다.
+
+```lua
+-- self.health는 자동으로 100을 기본값으로 셋팅함.
+-- 이 스크립트 컴포넌트를 포함하는 인스턴스의 초기값을 변경할 수 있음.
+go.property("health", 100)
+
+function on_message(self, message_id, message, sender)
+    -- 이제 "self.health"라는 속성값에 액세스 할 수 있음
+    ...
+end
+```
+
+스크립트 속성이 어떻게 동작하는지 어떻게 사용하는지 자세한 설명이 알고 싶다면 [Script properties](Script%20properties) 문서를 참고 바랍니다.  스크립트 속성을 정의하면 그 속성과 연관된 자료형으로 다른 보통의 속성들처럼 파일에 저장됩니다. 게임 오브젝트가 프로토타입에 의해 인스턴스화 된 경우엔 별도의 **component_properties** 속성이 스크립트 속성(향우엔 다른 컴포넌트에도 가능할지도)을 포함하는 오브젝트 인스턴스에 추가됩니다:
+
+![Script properties](images/building_blocks/building_blocks_properties.png)
+
+```json
+  component_properties {
+    id: "script"
+    properties {
+      id: "my_property"
+      value: "4712.0"
+      type: PROPERTY_TYPE_NUMBER
+    }
+  }
+```
+
+반대로 임베디드 된 게임 오브젝트에서 모든 컴포넌트 속성은 명시적으로 **properties** 속성으로 컬렉션 파일에 표시됩니다:
+
+![Embedded script properties](images/building_blocks/building_blocks_properties_embedded.png)
+
+```json
+data: "components {\n  id: \"some_script\"\n  component: \"/a_simple_test/my_thing.script\"\n  position {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n  }\n  rotation {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n    w: 1.0\n  }\n  properties {\n    id: \"my_property\"\n    value: \"4713.0\"\n    type: PROPERTY_TYPE_NUMBER\n  }\n}\ncomponents {\n  id: \"sprite\"\n  component: \"/a_simple_test/my_heart.sprite\"\n  position {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n  }\n  rotation {\n    x: 0.0\n    y: 0.0\n    z: 0.0\n    w: 1.0\n  }\n}\n"
+```
+
+## Collections
+컬렉션은 템플릿 생성을 위한 Defold의 메커니즘이며 다른 게임엔진에선 프리펩(prefab)이라고도 불려 지기도 합니다. 컬렉션은 게임 오브젝트들이나 또 다른 컬렉션들을 가지는 트리구조로 되어 있습니다. 컬렉션은 항상 파일에 저장되며 한두가지 방법으로 게임으로 불러올 수 있습니다:
+
+1. 빌드시 컬렉션을 에디터상의 다른 컬렉션에 배치하는 방법
+2. 런타임시 컬렉션 프록시(Collection proxy)를 사용해서 컬렉션에 모인 모든 리소스를 동적으로 로딩하는 방법(자세한 것은 [Collection proxy](Collection%20proxy)문서를 참고 바랍니다.)
+
+![Collection instances](images/building_blocks/building_blocks_collection_instances.png)
+
+에디터에 위치한 컬렉션들은 수정할 수 없습니다. 예를 들어 배치된 컬렉션의 일부인 게임 오브젝트에 하위 항목을 추가할 수 없습니다. 컬렉션 인스턴스에 저장된 데이터를 보면 잘 될거 같은데 왜 안될까요? 게임 오브젝트를 포함하고 있는 이 데이터는 "my_collection.collection"이라는 참조된 컬렉션 파일 안에 있고 이것은 수정되는 것이 아닙니다.
+
+컬렉션 파일 원본을 수정하지 않고는 컬렉션의 내용을 수정할 수 없지만, 에디터는 컬렉션에서 컴포넌트들과 연관된 스크립트 속성과 동일하게 속성값들의 수정을 허용합니다. 
+
+![Properties in a collection](images/building_blocks/building_blocks_collection_properties.png)
+
+```json
+collection_instances {
+  id: "my_collection"
+  collection: "/a_simple_test/my_collection.collection"
+  position {
+    x: -172.74739
+    y: 149.61157
+    z: 0.0
+  }
+  rotation {
+    x: 0.0
+    y: 0.0
+    z: 0.0
+    w: 1.0
+  }
+  scale: 1.0
+  instance_properties {
+    id: "my_gameobject"
+    properties {
+      id: "script"
+      properties {
+        id: "my_property"
+        value: "4717.0"
+        type: PROPERTY_TYPE_NUMBER
+      }
+    }
+  }
+}
+```
+
+> 많이들 헷갈리는 점은 컬렉션 계층구조의 게임 오브젝트의 위치가 런타임시에 부모-자식 계층(set_parent 메세지로 맺어진)으로 된다는 것이 있습니다. 여기서 두 가지 차이점을 깨닫는 것이 중요한데, 컬렉션은 관리 및 그룹화를 의미하는 반면, 부모-자식 계층은 오브젝트가 또다른 오브젝트와 시각적으로 연결되어 씬 그래프(scene graph)를 동적으로 수정하는 것을 의미합니다. 컬렉션 계층에서는 게임 오브젝트의 위치로 id를 지정하지만 이 id는 오브젝트의 수명기간 동안엔 정적(static)상태입니다. 게임 오브젝트의 주소 지정(addressing)에 대한 자세한 설명은 [Message passing](Message%20passing) 문서를 참고 바랍니다.

docs/ko/manuals/camera.md

@@ -0,0 +1,149 @@
+# Cameras
+Defold는 기본적인 카메라 컴포넌트(primitive camera component)를 가지고 있습니다. 이 메뉴얼은 이 컴포넌트의 기능과 용도에 대하여 설명합니다.
+
+카메라는 게임 월드의 뷰(view)를 제공하는데 사용하는 컴포넌트입니다. 카메라는 아래 기능을 수행하는 아주 간단한 오브젝트입니다.
+
+1. 2D나 3D 공간에 위치함
+2. 게임 오브젝트를 이 공간에서 움직일 수 있음
+3. 투영 매트릭스(projection matrix)와 뷰(computed view)를 계산해서 렌더링에 필요한 데이터를 렌더 스크립트에 제공함
+
+OpenGL의 카메라는 viewer, eye, position, near or far clipping plane 를 사용하여 좌표 시스템으로 표현 할 수 있습니다.  near clipping plane은  viewing plane 혹은 화면(screen)과 동일합니다.
+
+![Camera planes](images/cameras/cameras_planes.png)
+
+보통 3D카메라는 viewing volume, frustum, cut off pyramid 과 같은 모양(shape)을 가지고 있습니다. 이들의 효과로는 카메라로부터 멀리 있는 오브젝트를 작게 렌더링 해서, 시각(perspective)적으로 현실감 있게 보이게 합니다. 시야각(field of view)이 넓을 수록, 카메라로 더 넓은 풍경을 볼 수 있고, 가깝고 먼 오브젝트들을 더욱 드라마틱하게 보여줍니다.
+
+![Camera field of view](images/cameras/cameras_fov.png)
+
+## Creating a camera
+카메라를 생성하려면, 게임 오브젝트에 Camera component를 추가하세요.
+
+![Create camera component](images/cameras/cameras_create_component.png)
+
+카메라 컴포넌트는 카메라의 frustum(절두체)를 정의하는 프로퍼티의 모음을 가지고 있습니다.
+
+![Camera properties](images/cameras/cameras_properties.png)
+
+> 현재 기본 FOV 값은 오해의 소지가 있습니다. 각도(degrees)가 아니라 라디안(radians)으로 표시됩니다.  45 degree FOV를 하려면, 0.785 (PI / 4) 값으로 변경해야 합니다.
+
+#### aspect_ratio
+종횡비(aspect_ratio)는 frustum의 넓이와 높이 사이의 비율(ratio)입니다. 1.0은 이차 뷰(quadratic view)로 가정한다는걸 의미하며, 1.33은 1024x768 같은 4:3 비율 화면에서 잘 나오고. 1.78은 16:9 비율에서 잘 나옵니다.
+#### fov
+라디안(radians)으로 표현되는 카메라의 시야각(field of view)
+#### near_z
+near clipping plane의 Z-value
+#### far_z
+far clipping plane의 Z-value
+#### auto_aspect_ratio
+이 값을 1로 설정하면, 카메라는 게임 화면 설정을 기반으로해서 자동으로 종횡비(aspect ratio)를 셋팅합니다.
+
+## Camera focus
+카메라를 활성화하고 view와 projection의 matrix를 보내려면, 카메라 컴포넌트에게 acquire_camera_focus 메세지를 보내야 합니다.
+
+```lua
+msg.post("#camera", "acquire_camera_focus")
+```
+
+카메라 컴포넌트가 카메라 포커스를 획득하면, 렌더 스크립트 같은 곳의 매 프레임 마다 set_view_projection 메세지를 @render 소켓으로 보냅니다.
+
+```lua
+-- example.render_script
+--
+function update(self)
+    ...
+    render.set_view(self.view)
+
+    render.set_projection(self.projection)
+    ...
+end
+
+function on_message(self, message_id, message)
+    if message_id == hash("set_view_projection") then
+        -- 카메라의 view와 projection이 여기 도착함. 저장해 두자.
+        self.view = message.view
+        self.projection = message.projection
+    end
+end
+```
+
+만약 렌더 스크립트의 카메라 view와 projection를 둘 다 사용하면, 게임 컨텐츠가 완전히 2D 임에도 불구하고 3D perspective를 사용하여 게임월드의 카메라 view를 얻게 됩니다. 이것은 때때로 유용 하기도 합니다. 예를 들어, 카메라를 뒤로 움직여서 레벨의 전체 모습을 더 드러나게 할 수도 있습니다. 아래는 현재 카메라의 이동 속도를 측정하고 이 속도에 맞춰 카메라를 앞뒤로 땡기는 간단한 스크립트입니다.
+
+```lua
+-- camera.script
+--
+function init(self)
+    msg.post("#camera", "acquire_camera_focus")
+
+    -- 현재 위치를 저장하고 "look at" 메세지로 받을 위치값을 받을 변수 셋팅
+    self.pos = go.get_world_position()
+    self.look_at = self.pos
+    -- 측정 속도 저장하기
+    self.speed = 0
+end
+
+function update(self, dt)
+    -- 현재 위치와 목적지 위치를 보간한 값을 기준으로 새 위치를 계산함
+    self.pos = vmath.lerp(0.03, self.pos, self.look_at)
+
+    -- 2D 평면(2D plane)에서 속도 측정하기 (Z 는 0)
+    local v1 = go.get_world_position()
+    v1.z = 0
+    local v2 = self.pos
+    v2.z = 0
+    local speed = vmath.length(v2 - v1)
+
+    -- 플레이어의 이동 속도에 따라서 카메라를 뒤로 땡기든가 앞으로 밀든가 하기
+    self.pos.z = 500 + speed * speed * 10
+    go.set_position(self.pos)
+end
+
+function on_message(self, message_id, message, sender)
+    -- 이 카메라는 어느 위치로 이동하든 "look_at" 메세지에 반응함
+    if message_id == hash("look_at") then
+        self.look_at = message.position
+    end
+end
+```
+
+![Camera speed distance](images/cameras/cameras_speed_distance.png)
+
+물론, 우리는 카메라를 움직이는데 제약을 두고 있지 않습니다. 또한 X,Y,Z axis 축을 기반으로 회전할 수도 있습니다.
+
+```lua
+-- 0.314 라디안(radians)은 대략 18도(degrees)임...
+go.set_rotation(vmath.quat_rotation_z(0.314) * vmath.quat_rotation_y(0.314))
+```
+
+![Rotated camera](images/cameras/cameras_camera_rotated.png)
+
+## Orthographic projection
+많은 2D 게임에서, 앞 뒤로 움직이는 카메라를 사용하는 게임이 픽셀 퍼펙트(pixel perfect)로 렌더링 하려는 컨텐츠가 있다면 문제가 될 수 있습니다. 카메라를 완벽한 Z 거리(perfect Z distance)에 배치해서 원하는 시야(view)를 얻는 대신, 직교 투영(orthographic projection)으로 카메라를 설정하여 대신하는 것이 좋습니다. 즉, 카메라의 시야(view)가 더 이상 절두체(frustum)에 의해 좌우되지 않고, 더욱 간단한 상자(box)에 의해 좌우된다는 것을 의미합니다.
+
+![Orthographic projection](images/cameras/cameras_orthographic.png)
+
+직교 투영(Orthographic projection)은 거리에 따라 오브젝트의 크기를 변경하지 않으므로 비현실적으로 보이게 됩니다. 만약 한 사람이 카메라 10000 미터 멀리 서 있어도 카메라 바로 앞에 서 있는 사람과 동일한 크기로 렌더링 됩니다. 하지만, 이러한 그래픽 투영 방법은 때로 유용하며 2D 게임에서 자주 사용됩니다. 직교 투영(orthographic projection)을 사용하려면 렌더 스크립트를 수정해야 합니다.
+
+```lua
+-- example.render_script
+--
+function update(self)
+    ...
+    render.set_view(self.view)
+    -- 게임창의 넓이와 높이를 기반으로 직교 투영(orthographic projection) 설정하기
+    local w = render.get_width()
+    local h = render.get_height()
+    render.set_projection(vmath.matrix4_orthographic(- w / 2, w / 2, -h / 2, h / 2, -1000, 1000))
+    ...
+end
+
+function on_message(self, message_id, message)
+    if message_id == hash("set_view_projection") then
+        -- 카메라 view와 projection이 여기 도착함. 우린 view만 있으면 됨
+        self.view = message.view
+    end
+end
+```
+
+위의 예제는 화면을 카메라 위치의 중심에 맞추는 것을 제외하고는 기본 렌더 스크립트가 하는 것과 거의 같습니다.
+
+(몇몇 그래픽 에셋은 Kenney: http://kenney.nl/assets 에 의해 제작되었습니다.)

docs/ko/manuals/collection-factory.md

@@ -0,0 +1,65 @@
+# Collection factories
+컬렉션 팩토리 컴포넌트는 게임 오브젝트(컬렉션)의 설계도면 계층구조(blueprint hierarchies)를 만들어 실행중인 게임으로 스폰하는데 사용됩니다. 이 매뉴얼은 컬렉션 팩토리가 어떻게 동작하며 어떻게 사용하면 되는지 설명합니다.
+
+컬렉션은 재사용 가능한 템플릿(프리펩(prefab) 같은)을 생성하기 위한 강력한 메커니즘을 제공합니다. 컬렉션에 대한 개요를 보고 싶다면 [Building blocks](Building%20blocks) 문서를 참고 바랍니다. 컬렉션은 에디터상에서 배치해도 되고 컴파일 타임에 게임으로 복제할 수도 있는데, 동적으로 게임에 추가하는 방법으로는 아래 두 가지가 있습니다.
+
+1. 컬렉션 프록시(Collection proxy)를 통해 로드하는 방법. 이 방법은 근본적으로 고립된 새 월드(new isolated world)(물리 반응 방식을 포함함)를 실행중인 게임에 불러옵니다. 로드된 컬렉션은 새 소켓 으로 엑세스할 수 있으며, 컬렉션에 포함된 모든 에셋은 프록시가 로딩을 시작한다는 메세지를 받으면 프록시를 통해 로드됩니다. 이 방식은 레벨 스테이지를 변경하려는 경우에 아주 유용하게 사용됩니다. 더 많은 정보를 알고 싶다면 [Collection proxy](Collection%20proxy) 문서를 참고 바랍니다.
+
+2. 컬렉션 팩토리(Collection factory) 컴포넌트는  현재의 메인 컬렉션에 컬렉션 프록시의 컨텐츠를 스폰 할 수 있게 해줍니다. 이 방식은 마치 어떤 컬렉션 안에 있는 모든 오브젝트들에게 일일히 팩토리(factory) 컴포넌트를 넣어서 오브젝트간 부-모 계층을 만드는 방식과 유사합니다. 일반적인 사용처로는 게임 오브젝트가 여러 개의 게임 오브젝트로 구성된 적(enemy: 몸체+무기) 같은 개체를 스폰하는데 유용합니다.
+
+## Spawning a collection
+컬렉션을 스폰 하는 것은 게임 오브젝트를 스폰하는 방식과 똑같이 수행됩니다. 간단한 예를 들자면, 우리가 행성 스프라이트를 만들고 이 행성 표면에 복합적인 게임 오브젝트로 구성된 우주인 모형 여러 개를 스폰해야 한다고 칩시다. 우리는 그냥 컬렉션 프록시(**Collection factory**)를 "planet" 게임오브젝트에 추가하고 **Prototype** 속성을 "astronaut.collection" (일단 존재한다고 치고)으로 설정하면 됩니다.
+
+![Collection factory](images/collection_factory/collection_factory_factory.png)
+
+이번엔 팩토리에게 우주인을 스폰하라는 메세지를 보내면 됩니다.
+
+```lua
+local astro = collectionfactory.create("#factory", nil, nil, {}, nil)
+```
+스폰된 우주인은 게임 오브젝트들의 트리구조로 되어 있으며, 스폰 이후에 이 오브젝트들을 다루기 위한 주소를 받을 수 있습니다.
+
+![Collection to spawn](images/collection_factory/collection_factory_collection.png)
+
+보통의 팩토리 컴포넌트라면 스폰된 오브젝트의 아이디(id)를 반환하지만, 컬렉션 팩토리는 각 오브젝트들의 런타임 아이디를 컬렉션명-로컬명(collection-local id)의 해쉬값으로 만들고 이들을 테이블에 매핑해 반환합니다. 접두사 "/collectionNN/" 가 각 아이디에 추가되어 각 인스턴스를 유니크하게 식별해 줍니다.
+
+```lua
+pprint(astro)
+-- DEBUG:SCRIPT:
+-- {
+--   hash: [/probe2] = hash: [/collection0/probe2],
+--   hash: [/probe1] = hash: [/collection0/probe1],
+--   hash: [/astronaut] = hash: [/collection0/astronaut],
+-- }
+```
+
+"astronaut"과 "probe" 사이의 부-모 관계는 오브젝트의 id/path 에 영향을 주지 않지만 런타임시에 씬-그래프(scene-graph)에서는 영향을 줍니다. 예를 들면 부-모 관계의 오브젝트들을 함께 트랜스폼(이동,회전,스케일)하거나 오브젝트의 부-모를 재설정하는 것으로는 절대 id가 바뀌지 않습니다.
+
+## Properties
+컬렉션을 스폰 할 때, 컬렉션-로컬(collection-local) 오브젝트 아이디가 쌍(pair)으로 구성된 테이블을 사용하여 각각의 부분 게임 오브젝트에게 적당한 파라미터를 보낼 수 있으며, 이는 각 스크립트 속성을 셋팅합니다.
+
+```lua
+-- planet.script
+--
+local props = {}
+props[hash("/astronaut")] = { size = 10.0 }
+props[hash("/probe1")] = { color = hash("red") }
+props[hash("/probe2")] = { color = hash("green") }
+local astro = collectionfactory.create("#factory", nil, nil, props, nil)
+...
+```
+"astronaut"가 스폰된 각각의 인스턴스들은 넘겨진 값으로 "size" 속성을 셋팅하게 되고, 각 "probe" 들은 "color" 속성이 셋팅됩니다.
+
+```lua
+-- probe.script
+--
+go.property("color", hash("blue"))
+
+function init(self)
+  ...
+```
+
+우주인 여러 명을 스폰하고 적당히 배치하여 알맞은 속성 값들을 보내면, 아래처럼 사랑이 넘치는 행성을 만들 수 있습니다.
+
+![Populated planet](images/collection_factory/collection_factory_game.png)
+

docs/ko/manuals/collection-proxy.md

@@ -0,0 +1,312 @@
+# Collection Proxies
+Defold는 컬렉션에 모든 게임 오브젝트를 구성합니다. 이 매뉴얼은 게임 실행중에 동적으로 컬렉션을 로드하고 언로드하는 방법에 대해 설명합니다.
+
+컬렉션에는 게임 오브젝트를 추가할 수 있으며, 심지어 다른 컬렉션을 추가 할 수도 있습니다(예: 서브-컬렉션). Defold가 실행되면 project settings에 정의된 최상위 컬렉션(top level collection)이 로드(loads), 개시(initiates), 활성화(enables) 되며, 대부분 프로젝트 생성시 게임 실행 즉시 처음으로 실행되는 "main.collection"도 함께 생성됩니다.
+
+대다수 프로젝트에서는, 최상위 컬렉션에만 전체 앱을 포함하는 것으로 충분하지만, 프로젝트를 구성하기 위해 더 강력한 방법으로 여러 최상위 컬렉션들을 동적으로 로딩하고 언로딩 하는 여러 예제(아래 참고)가 있습니다.
+
+컬렉션 프록시(Collection proxy)는 컬렉션 파일 대신 사용되는 창구 역할을 하며, 이 프록시를 이용하여 아직 로드되지 않은 컬렉션 파일과 load, initialize, enable, disable, finalize, unload의 커뮤니케이션을 할 수 있습니다.
+
+로딩과 언로딩에 관련된 컬렉션 프록시를 사용하는 모든 커뮤니케이션은 비동기적(asynchronously)으로 수행되지만, 실제로 로딩과 언로등이 백그라운드 프로세스에서 구현되는 것은 아닙니다. 그러므로 엔진이 실제 로딩이나 언로딩을 발생하면 짧게 중지(pause)될 것입니다.
+
+## Typical use cases
+많은 게임들은 난이도 순서대로 플레이 할 수 있게 여러 레벨로 나누어져 있습니다. 만약 레벨 컨텐츠가 그냥 에디터상에서 수동으로 구성된 경우, 레벨 안의 요소들(타일맵, 스프라이트 등)은 그저 컬렉션 모음으로 끝나버릴 것입니다. 컬렉션 프록시는 이 컨텐츠들을 분리하고 스크립트를 통해 동적으로 관리할 수 있게 해 줍니다.
+
+아래는 컬렉션 프록시(collection proxy)의 예시입니다.
+
+* 게임 레벨의 Loading/unloading
+* GUI 프론트엔드의 Loading/unloading
+* 게임 레벨의 스토리 같은걸 보여주는 씬(scene)의 Loading/unloading
+* 미니게임의 Loading/unloading
+* 사용자가 선택한 컨텐츠(음악, 배경이미지 등)의 Loading/unloading
+
+> 큰 심리스 월드에서 "streaming" 지역을 로딩/언로딩 하는 것은 컬렉션 프록시를 활용하여 구현 가능합니다. 하지만 실제 로딩은 동기식(백그라운드에서 동작하지 않고, 로딩이 완료될 때까지 게임을 중단하는것을 의미함)으로 수행되며 로딩 시간에 여러 프레임이 걸릴 수 있습니다. 그러므로 월드의 조각을 작게 유지하거나 로딩으로 인한 멈춤을 어떻게든 숨기는 방법을 찾아야 합니다.
+
+## Worlds
+컬렉션 프록시를 통하면 최상위 컬렉션을 전환하거나 한 개 이상의 최상위 컬렉션을 게임 엔진에 로드하는 것이 가능합니다. 단, 각 최상위 컬렉션은 분리된 물리 월드이며 물리 상호작용(Physics interactions: collisions, triggers, ray-casts)은 동일한 컬렉션에 소속된 오브젝트 끼리만 발생한다는 것을 알아 둬야 합니다. 즉, 각기 다른 최상위 컬렉션에 소속된 오브젝트들 사이에서는 물리 상호작용이 발생하지 않습니다.
+
+아래 예제에서는 게임 월드를 컬렉션 프록시를 통해 동적으로 로드되는 두 개의 컬렉션으로 분할했습니다. 두 컬렉션의 로드 및 언로드는 "loader"라는 게임 오브젝트에 의해 제어되며 이 오브젝트는 메인 컬렉션인 "worlds"에 들어 있습니다. 게임이 시작될때  "worlds.collection" 파일을 자동으로 로드하도록 구성([Project settings](Project%20settings) 참고)합니다. "world" 컬렉션은 "loader" 오브젝트 뿐만아니라 우리가 캐릭터를 움직일 수 있게 해주는 GUI 요소도 포함하고 있습니다.
+
+![Worlds 1](images/collection_proxies/collection_proxy_worlds_loader.png)
+
+첫번째 컬렉션 "world1"은 왼편에 보라색 바닥의 타일이 있습니다. 오른편의 "exit" 표지판과 녹색 바닥 타일은 "world2" 컬렉션입니다.
+
+![Worlds 1](images/collection_proxies/collection_proxy_worlds_1.png)
+
+우리의 플레이어 캐릭터는 레벨의 모든 바닥 타일에 대해 물리 충돌이 셋팅되어 있으며 플레이어가 바닥 위의 캐릭터를 데굴데굴 굴릴 수 있게 해 줍니다. 하지만 플레이어가 "world1" 컬렉션의 끝에 닿으면 어떤 일이 일어나는지 봅시다.
+
+![Worlds 2](images/collection_proxies/collection_proxy_worlds_2.png)
+
+"world2"의 타일은 "world1"과 완전히 동일하게 충돌 셋팅이 되어 있지만, "world1" 에 소속된 플레이어 캐릭터 게임 오브젝트는 충돌이 발생하지 않고 캐릭터가 그냥 아래로 뚝 떨어져 버립니다.
+
+만약 모든 레벨들이 한 컬렉션 내에 전부 포함되어 있고, 플레이어가 이들 레벨 사이를 원활하게(seamlessly) 이동하지 못할 것으로 예상되는 게임에서는, 이러한 컬렉션의 특성 때문에 월드를 분리하는데 사용되기 어렵습니다.
+
+나중에 이 예제를 자세히 살펴보고 게임이 물리 충돌, 트리거를 어떻게 사용하는지, 플레이어가 이동할 수 있는 게임월드 조각을 동적으로 어떻게 로드하는지도 살펴 보도록 하겠습니다. 하지만 우선 컬렉션 프록시의 기초부터 살펴 보도록 합시다.
+
+## Editing
+컬렉션 프록시를 설정하기 위해서는, 게임 오브젝트에 컬렉션 프록시 컴포넌트를 추가하고 프록시의 이름을 정하고(id 지정) 어떤 컬렉션 파일이 이를 대신하여 작동할지 지정하면 됩니다.
+
+![Editing](images/collection_proxies/collection_proxy_editing.png)
+
+## Naming collections
+컬렉션 프록시와 커뮤니케이션을 시작하기 전에, 각 컬렉션들의 이름을 확인 해야 합니다. 에디터에서 생성한 각 컬렉션은 "default"라는 이름으로 자동 할당 됩니다. 프록시를 통해 컬렉션을 동적으로 로드하지 않는 한, 이 이름을 유지할 수 있습니다.
+
+![Naming](images/collection_proxies/collection_proxy_name.png)
+
+하지만 컬렉션 프록시를 통해 두 개 이상의 최상위 레벨 컬렉션을 로드하는 경우, 각 컬렉션은 URL의 소켓 부분을 통해 주소가 지정되어야 하고, 이 소켓 이름은 반드시 유니크해야만 합니다.
+
+```lua
+msg.post("world1:manager#script", "remove_player")
+msg.post("world2:manager#script", "spawn_player")
+```
+
+그러므로 프록시를 통해 로드하려는 컬렉션은 유니크한 이름으로 수정하는것이 좋습니다. 만약 유니크한 이름을 지정하지 않으면 엔진은 이름 충돌 에러를 발생합니다.
+
+```
+ERROR:GAMEOBJECT: The collection 'default' could not be created since there is already a socket with the same name.
+WARNING:RESOURCE: Unable to create resource: build/default/worlds/world1.collectionc
+ERROR:GAMESYS: The collection /worlds/world1.collectionc could not be loaded.
+```
+
+## Loading
+프록시를 통해 컬렉션을 로드하려면 "load" 메세지를 게임 오브젝트의 프록시 컴포넌트에게 전송하면 됩니다.
+
+```lua
+-- "world1" 프록시에게 로딩 시작하라고 알려줌
+msg.post("loader#world1", "load")
+```
+
+프록시가 로딩을 끝내면 "proxy_loaded" 메세지를 되돌려 줍니다. 이 메세지를 받아서 컬렉션을 초기화(initialize) 하고 활성화(enable) 할 수 있습니다.
+
+```lua
+function on_message(self, message_id, message, sender)
+        if message_id == hash("proxy_loaded") then
+                -- 뉴 월드가 로드되었다. Init과 enable 하자
+                msg.post(sender, "init")
+                msg.post(sender, "enable")
+                ...
+```
+
+아니면 메세지의 출처를 체크해서 그에 맞는 처리를 하게 하는 것도 가능합니다. "proxy_loaded" 를 보낸 컬렉션 프록시는 sender URL의 프래그먼트 부분(fragment part)에 표시됩니다.
+
+```lua
+function on_message(self, message_id, message, sender)
+        if message_id == hash("proxy_loaded") and sender.fragment == hash("myproxy1") then
+                -- "myproxy1"가 로드되면 init 하고 enable 하자...
+                ...
+```
+
+"init" 메세지로 프록시를 통해 컬렉션을 초기화(Initializing) 하는 것은 컬렉션에 포함된 모든 오브젝트들을 재귀적으로(recursively) 초기화 합니다. "enable" 메세지로 프록시를 통해 컬렉션을 활성화(Enabling)하는 것도 컬렉션에 포함된 모든 오브젝트들을 재귀적으로 활성화 하게 됩니다.
+
+(오브젝트의 생명주기에 대해 자세히 보고 싶다면 [Application lifecycle](Application%20lifecycle) 참고)
+
+"enable"을 로드된 프록시에게 보내면 enable을 수행하기 전에 컬렉션을 자동으로 초기화(init) 합니다. 그러므로 초기화와 활성화 단계 별로 세분화 된 제어가 필요한게 아니라면 그냥 아래처럼 써도 됩니다.
+
+```lua
+-- 뉴 월드가 로드되었다. Init과 enable 하자
+msg.post(sender, "enable")
+```
+
+다시 플랫포머 예제로 돌아와서, "world1" 컬렉션에 트리거를 하나 넣고 "world2"를 로드할 위치에 배치 하도록 합니다.
+
+![Trigger](images/collection_proxies/collection_proxy_trigger.png)
+
+
+우리는 "worldswitch"라는 게임 오브젝트에 전환 로직(switching logic)이 포함된 트리거를 만들고, 오브젝트를 재사용 할 수 있게 해 주는 두 프로퍼티를 묶습니다. 이 프로퍼티는 해쉬 형식이므로 프록시들이 커뮤니케이션 할 수 있도록 URL을 구성해야 합니다. 우리는 "loader" 게임 오브젝트가 추가된 "worlds" 컬렉션에 이 메세지들를 보낼 계획입니다.
+
+```lua
+go.property("selfworld", hash(""))
+go.property("otherworld", hash(""))
+
+function init(self)
+        -- 프록시들을 위한 url 구성하기... 나중에 사용할 예정임
+        self.selfurl = msg.url()
+        self.selfurl.socket = "worlds"
+        self.selfurl.path = hash("/loader")
+        self.selfurl.fragment = self.selfworld
+        self.otherurl = msg.url()
+        self.otherurl.socket = "worlds"
+        self.otherurl.path = hash("/loader")
+        self.otherurl.fragment = self.otherworld
+end
+```
+
+여기서는 "world2" 컬렉션을 셋팅합니다.
+
+![Trigger world 2](images/collection_proxies/collection_proxy_trigger_2.png)
+
+"exit" 표지판을 두 컬렉션에서 완전히 동일한 좌표에 배치해서 하나의 타일로 겹쳐 보이게 합니다.
+또한 "world1" 뿐만 아니라 "world2" 에도 "player" 오브젝트가 필요 합니다. 각 컬렉션은 각자 자체의 물리 세계(physics world)를 가지고 있기 때문에 플레이어 또한 별도로 있어야 하며 월드 사이를 넘어 갈 때  입력 제어(input control)와 포지션을 한 쪽 플레이어에서 다른 쪽 플레이어로 넘길 것입니다.
+
+그러므로 플레이어가 "world1"의 트리거와 충돌하면, 우리는 "world2" 로딩을 시작하면 됩니다.
+
+```lua
+function on_message(self, message_id, message, sender)
+        if message_id == hash("trigger_response") and message.enter then
+                -- 플레이어가 월드 전환 트리거와 충돌함
+                -- 예전에 구성해 놓은 url을 통해 참조된 다음 월드 불러오기
+                msg.post(self.url, "load")
+                ...
+```
+
+다음으로는, 로드 작업이 완료되면 컬렉션을 활성화 합니다.
+
+```lua
+        elseif message_id == hash("proxy_loaded") then
+                -- 새 월드가 로드 되었으니 Enable 하자
+                msg.post(sender, "enable")
+```
+
+이제는 플레이어 오브젝트를 전환 시킬 때입니다. 우리는 현재 플레이어에게 현재 포지션 등등의 필요한 데이터를 요구하는 메세지를 전송해서 플레이어 전환 작업을 시작합니다.
+
+```lua
+                -- 플레이어의 위치를 다른 월드의 플레이어에게 전송해야함
+                local currentsocket = ""
+                -- 해쉬된 프로퍼티는 문자열로 만들 수 없으므로 이렇게 해야함
+                if self.selfworld == hash("world1") then
+                        currentsocket = "world1"
+                elseif self.selfworld == hash("world2") then
+                        currentsocket = "world2"
+                end
+                msg.post(currentsocket .. ":" .. "/player#script", "request_player")
+```
+
+여기서는 "player_response" 메세지를 받아서 새로 로드된 컬렉션의 플레이어에게 데이터를 보내 줍니다.
+
+```lua
+        elseif message_id == hash("player_response") then
+                -- 플레어어 포지션 값을 돌려 받아서..
+                -- 다른 월드의 플레이어에게 반영해야 함
+                local othersocket = ""
+                if self.otherworld == hash("world1") then
+                        othersocket = "world1"
+                elseif self.otherworld == hash("world2") then
+                        othersocket = "world2"
+                end
+                -- 받은 메세지를 걍 넘김
+                msg.post(othersocket .. ":" .. "/player#script", "inherit_player", message)
+        end
+```
+
+"inherit_player" 메세지는 전송한 포지션을 상속하므로 새 플레이어는 이전 플레이어와 동일한 위치로 재배치 됩니다. (여기서, 서로 다른 컬렉션에 있고 물리 세계도 구분되므로 새 플레이어는 트리거 충돌이 감지되지 않습니다.)
+
+이제 게임을 실행하면 "world1"에서 "world2"로 이동할 수 있지만 "world1"의 플레이어 오브젝트가 아직도 존재하고 있고 "world2"의 월드로 넘어가면 뚝 떨어지게 됩니다.
+
+![Loading 1](images/collection_proxies/collection_proxy_loading_1.png)
+
+그러나 이제 우리는 "world2"의 플레이어를 제어할 수 있고 새 레벨로 캐릭터를 굴릴 수 있습니다.
+
+![Loading 2](images/collection_proxies/collection_proxy_loading_2.png)
+
+
+## Unloading
+이제 우리는 월드 전환 로직을 조금 정리하기만 하면 됩니다. 설명을 위해서 우리가 남겨둔 컬렉션을 간단하게 언로드 해보겠습니다. 하지만 우선, 언로드가 어떻게 동작하는지 부터 살펴봅시다.
+
+언로딩은 로딩때와는 반대 순서로 처리합니다.
+
+```lua
+msg.post("loader#world1", "disable")
+msg.post("loader#world1", "final")
+msg.post("loader#world1", "unload")
+```
+
+"disable" 메세지로 프록시를 통해 컬렉션을 비활성화(Disabling) 하는 것은 컬렉션에 포함된 모든 오브젝트들을 재귀적으로(recursively) 비활성화 합니다. "final" 메세지로 프록시를 통해 컬렉션을 마무리(Finalizing)하는 것도 컬렉션에 포함된 모든 오브젝트들을 재귀적으로 마무리 하게 됩니다. 그리고 "unload" 메세지는 컬렉션을 메모리에서 삭제합니다.
+
+프록시가 컬렉션을 언로드하면 "proxy_unloaded" 메세지를 보내줍니다.
+
+```lua
+if message_id == hash("unload_level") then
+    local proxy = msg.url("#proxy")
+    msg.post(proxy, "disable")
+    msg.post(proxy, "final")
+    msg.post(proxy, "unload")
+elseif message_id == hash("proxy_unloaded") then
+    -- Ok, 레벨이 언로드 되었구만
+    ...
+```
+
+세세한 컨트롤이 필요한게 아니라면, 컬렉션을 disable, final 하지 않고 그냥 "unload" 메세지를 보내도 됩니다. 프록시가 unload 되기 전에 컬렉션을 자동적으로 disable하고 finalize 합니다.
+
+이제 다시 우리의 플랫포머 예제로 돌아와서, 우리가 해야 할 남은 일은 올바른 프록시로 이 메세지들을 보내는 것 뿐입니다. 우리는 데이터 요청을 위한 "request_player" 메세지를 새 플레이어 오브젝트에게 보낸 이후에 언로드 작업을 수행합니다.
+
+```lua
+...
+msg.post(currentsocket .. ":" .. "/player#script", "request_player")
+
+-- 이제 남겨진 월드를 버릴 때가 되었음
+-- 화면에 다 보이는데서 삭제해버리는게 이상하게 보이지만, 작동 원리 이해를 위해 걍 삭제함
+msg.post(self.selfurl, "disable")
+msg.post(self.selfurl, "final")
+msg.post(self.selfurl, "unload")
+```
+
+이제 왼쪽의 컬렉션은 플레이어를 뒤로 하고 언로드 되게 됩니다.
+
+![Unloading](images/collection_proxies/collection_proxy_unloading.png)
+
+실제 게임에서라면 화면에 보이는 상태에서는 컬렉션을 언로드하지 않는게 좋습니다. 만약 플레이어의 전환(switching)을 더욱 부드럽게 만들고 싶다면, 플레이어 컨트롤에 따른 가속도(momentum)와 플레이어의 애니메이션 상태(animation state)를 상속 받아 처리하거나 전환 지점을 특정 효과 같은거로 가려 버리는 것도 좋은 방법입니다. 이 심플한 예제는 단지 이전 플레이어의 포지션만 상속할 뿐이라 각도(angular)와 선형 속도(linear velocity)가 0으로 설정됩니다.
+
+## Input
+만약 로드된 컬렉션에서 인풋 액션(input action)이 필요한 오브젝트가 있다면, 컬렉션 프록시를 포함하고 있는 게임 오브젝트가 입력을 획득(acquire)하는지 확인할 필요가 있습니다. 게임 오브젝트가 입력 메세지를 수신하면, 이들은 오브젝트의 컴포넌트, 즉 컬렉션 프록시들에게 전파(propagated)됩니다. 인풋 액션은 로드된 컬렉션에게 프록시를 통해서 전달되게 됩니다.
+
+![Input](images/collection_proxies/collection_proxy_input.png)
+
+"world1"이나 "world2"에 소속된 오브젝트에서 인풋액션을 받기 원한다면, 간단하게 "loader" 게임오브젝트의 스크립트에서 인풋 포커스(input focus)를 획득하면 됩니다.
+
+```lua
+function init(self)
+        -- 입력을 획득해서 컬렉션 오브젝트들이 입력을 받을거임
+        msg.post(".", "acquire_input_focus")
+        ...
+```
+
+이제 "world1" 또는 "world2"의 오브젝트가 "acquire_input_focus" 메세지를 보내서 인풋 액션을 받을 수 있습니다. (입력에 대한 자세한 정보는 [Input](Input)을 참고하세요.)
+
+
+## Time step
+각 컬렉션 프록시는 어플리케이션의 업데이트 주기와 관련된 타임스텝(time step)을 업데이트 하는것을 개별적으로 제어할 수 있습니다. 글로벌 업데이트 주기(global update frequency)는 어플리케이션 프로젝트 셋팅(초당 60 프레임 업데이트를 기본값으로 함)에서 설정하거나 @system 소켓으로 메세지를 보내서 설정할 수도 있습니다.
+
+```lua
+msg.post("@system:", "set_update_frequency", { frequency = 60 } )
+```
+
+컬렉션 프록시의 업데이트는 time step을 변경해서 스케일(scale) 할 수 있습니다. 즉 게임 틱(tick)이 꾸준하게 60FPS 라도, 프록시는 더 높거나 더 낮은 페이스(pace)로 업데이트 할 수 있으며, 물리 시스템과 update() 함수에 넘겨주는 "dt" 변수에 영향을 미치게 됩니다. 또한 업데이트 모드(update mode)를 설정하여 스케일링이 불연속적으로(discretely) 수행되어야 하는지(1.0 이하의 스케일 펙터(scale factor)에서만 의미가 있음) 연속적으로(continuously) 수행되어야 하는지를 제어할 수 있게 해 줍니다.
+
+프록시에 "set_time_step" 메세지를 보내서 스케일 펙터(scale factor)와 스케일링 모드(scaling mode)를 제어할 수 있습니다.
+
+```lua
+-- 프록시 컬렉션을 1/5 속도로 업데이트 함
+msg.post("#proxy", "set_time_step", {factor = 0.2, mode = 1}
+```
+
+time step을 변경하면 무슨 일이 발생하는지 보려면, 오브젝트를 만들어 스크립트 컴포넌트에 아래 코드를 추가하고 timestep을 변경하려는 컬렉션에 넣으면 됩니다.
+
+```lua
+function update(self, dt)
+        print("update() with timestep (dt) " .. dt)
+end
+```
+
+time step을 0.2로 설정했기 때문에, 콘솔창에서 아래와 같은 결과가 출력됩니다.
+
+```
+INFO:DLIB: SSDP started (ssdp://192.168.0.102:54967, http://0.0.0.0:62162)
+INFO:ENGINE: Defold Engine 1.2.37 (6b3ae27)
+INFO:ENGINE: Loading data from: build/default
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0.016666667535901
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0
+DEBUG:SCRIPT: update() with timestep (dt) 0.016666667535901
+```
+
+update() 는 여전히 초당 60번 호출 되지만 "dt"값은 바뀌게 됩니다. update()를 호출하는 1/5 (0.2) 만이 1/60 (60fps)에 해당하는 "dt"를 가지게 되며, 나머지는 0이 됩니다. 또한 모든 물리 시뮬레이션은 dt에 따라 업데이트 되며 오직 프레임 당 1/5만 진행됩니다.
+
+자세한 내용은 [set_time_step](http://www.defold.com/ref/collectionproxy/#set_time_step) 를 참고 바랍니다.
+
+(일부 그래픽 에셋은 Kenney에 의해 제작되었습니다 : http://kenney.nl/assets)

docs/ko/manuals/debugging.md

@@ -0,0 +1,172 @@
+# Debugging
+이 매뉴얼은 Defold에 있는 디버깅 기능에 대해 설명합니다.
+
+Defold에서 게임을 디버그하는 가장 간단한 방법은 [출력 디버깅(print debugging)](http://en.wikipedia.org/wiki/Debugging#Techniques)을 사용하는 것입니다. 이 기술은 그냥 print()나 [pprint()](http://www.defold.com/ref/builtins#pprint) 함수를 사용해서 변수의 값을 살펴보고 실행 흐름을 추적하는 방법입니다. 만약 스크립트가 없는 게임 오브젝트가 이상하게 동작한다면, 디버깅 용도의 스크립트를 추가하면 됩니다.
+
+출력 함수를 사용하면 Editor의 Console 창에 값이 출력됩니다. 또한 draw_text 메세지를 @render 소켓으로 보내서 화면에 텍스트를 그릴 수도 있습니다.
+
+```lua
+msg.post("@render:", "draw_text", {text = "My value: " .. my_val, position = vmath.vector3(200, 200, 0)})
+```
+
+물리 움직임을 계산하는데 문제가 생겼다면, 화면에 선(line)을 그려서 계산을 시각적으로 표현하는 것이 도움이 되기도 합니다. 이 방법은 draw_line 메세지를 @render 소켓으로 보내서 그릴 수 있습니다.
+
+```lua
+msg.post("@render:", "draw_line", {start_point = my_start, end_point = my_end, color = my_color})
+```
+
+Lua는 몇몇 상황에서 유용한 디버깅 라이브러리를 제공합니다. 특히 Lua 환경의 내부를 조사해야 하는 경우 필요할 수도 있습니다. 더 많은 정보는 http://www.lua.org/pil/contents.html#23 를 참고 바랍니다.
+
+## Debugging Lua scripts with ZeroBrane
+Defold 엔진은 Lua IDE ZeroBrane Studio 라는 무료 오픈소스를 통해 Lua 스크립트를 디버깅하기 위한 기능을 내장하고 있습니다. 디버깅 기능을 위해서는 ZeroBrane Studio를 설치해야 합니다. 이 프로그램은 OSX와 Windows에서 실행 가능합니다.
+
+http://studio.zerobrane.com 에서 "ZeroBrane Studio"를 다운로드 하세요.
+
+### ZeroBrane configuration
+ZeroBrane이 프로젝트의 파일들을 찾으려면, Defold 프로젝트 디렉토리의 위치를 알려줘야 합니다. 간단한 방법으로는 Defold project에서 **Show in Finder/Explorer** 메뉴로 찾을 수 있습니다.
+
+1. "game.project" 에서 마우스 오른쪽 클릭
+2. OSX에서 **Show in Finder** 선택, Windows에서 **Show in Explorer** 선택
+
+OS X:
+![Show in Finder](images/debugging/showinfind.png)
+
+Windows:
+![Show in Explorer](images/debugging/showinwin.png)
+
+### To set up ZeroBrane
+ZeroBrane을 설정하기 위해 **Project ▸ Project Directory ▸ Choose…​** 를 선택하세요.
+
+![Auto completion](images/debugging/setup.png)
+
+이렇게 현재 Defold 프로젝트 디렉토리와 일치하게 설정하면, ZeroBrane에서 Defold 프로젝트의 디렉토리 트리 구조가 보이게 되며 이 파일들을 열거나 다룰 수 있게 됩니다.
+
+추천하는 다른 구성 방법은 아래 문서에서 자세히 설명하도록 하겠습니다.
+
+### Starting the debugging server
+디버깅 세션을 시작하기 전에, ZeroBrane에 내장된 디버깅 서버가 실행되어야 합니다. 이 메뉴는 **Project** 메뉴에서 찾을 수 있으며 **menu:Project ▸ Start Debugger Server**를 선택하면 됩니다.
+
+![Auto completion](images/debugging/startdebug.png)
+
+### Connecting your application to the debugger
+디버깅은 Defold 어플리케이션의 생명주기의 어느 지점에서든 시작할 수 있지만, Lua 스크립트에서 우선적으로 시작되어야 합니다. 디버깅 세션을 시작하기 위한 Lua 코드는 아래처럼 작성할 수 있습니다.
+
+```lua
+local dbg = require "builtins.scripts.mobdebug"
+dbg.start()
+```
+
+위 코드를 어플리케이션에 추가해서, ZeroBrane의 디버깅 서버와 연결(기본값으로 "localhost"로 연결됨)되고 다음 구문이 실행되기 전에 중지(pause) 됩니다.
+
+> dbg.start()가 호출되었을 때 게임이 종료되어 버린다면, ZeroBrane이 문제를 감지하여 게임으로 종료 커맨드(exit command)를 전송했기 때문일 수도 있습니다. 몇 가지 이유로 인해, ZeroBrane은 디버깅 세션을 시작하기 위해 어떤 파일을 열어야 할 필요도 있을 수 있습니다. 만약 ZeroBrane에서 "Can’t start debugging without an opened file or with the current file not being saved (untitled.lua)."(번역: 열린 파일이나 현재 파일이 저장되지 않은 상태에서 디버깅을 시작할 수 없습니다.) 에러가 발생하면 dbg.start() 가 추가된 해당 파일을 열어 이 에러를 수정하십시오.
+
+> 디버깅은 디버깅이 시작된 위치에서만 lua 컨텍스트를 활성화 할 수 있습니다. game.project에서 "shared_state"를 활성화 하면 디버깅이 시작된 위치와 상관없이 모든 어플리케이션을 디버깅 할 수 있습니다.
+
+Debugging session started in "<defold-dir>/branches/1610/1159/Main/".
+(디버깅 세션이 "<defold-dir>/branches/1610/1159/Main/" 에서 시작되었습니다.) 
+
+라는 메세지가 나타나면 이제 ZeroBrane에서 디버깅 기능을 사용할 수 있게 되어 중단점(breakpoint)를 추가 삭제해서 단계별로 검사할 수 있습니다.
+
+![Auto completion](images/debugging/code.png)
+
+연결 시도가 실패했다면(디버깅 서버를 실행하지 않았거나 해서), 연결 시도 후에 정상적으로 어플리케이션을 계속 실행합니다.
+
+### Remote debugging
+디버기깅은 일반 네트워크 커넥션 (TCP)에서 발생하므로 원격으로 디버깅이 가능합니다. 즉 모바일 장치가 실행되는 동안 어플리케이션을 디버그 하는것도 가능합니다.
+
+디버깅을 시작하기 위해선 기본적으로 start() 를 호출해 localhost로 연결을 시도할 수 있지만 아래처럼 ZeroBrane의 디버깅 서버에 접속하기 위해 특정 주소를 직접 수정할 수도 있습니다.
+
+```lua
+local dbg = require "builtins.scripts.mobdebug"
+dbg.start("192.168.5.101")
+```
+
+또한 이 기능은 8172 포트를 통해 TCP 연결되므로 방화벽 등의 소프트웨어가 원격 장치와의 연결을 막고 있지 않은지 체크하는 것이 중요합니다. 그렇지 않으면 어플리케이션이 디버깅 서버에 연결하려고 시도할 때 중단될 수 있습니다.
+
+### Other recommended ZeroBrane setting
+디버깅 하는 동안 ZeroBrane이 자동으로 Lua 스크립트 파일을 열도록 할 수도 있습니다. 이 기능은 수동으로 파일을 열지 않아도 다른 소스 파일의 함수 정보를 단계적으로 열 수 있습니다.
+
+우선 에디터의 configuration 파일을 열어서 사용자용 버전으로 수정해야 합니다.
+
+1. **Edit ▸ Preferences ▸ Settings: User** 메뉴 선택
+2. configuration 파일에 아래 항목을 추가함
+    ```
+    - 디버깅하는 동안 요구되는 파일을 자동으로 염
+    editor.autoactivate = true
+    ```
+3. ZeroBrane을 재시작
+
+![Other recommended settings](images/debugging/otherrecommended.png)
+
+## Hot reloading
+Defold는 리소스들을 핫리로드 할 수 있습니다. 게임을 개발중일 때 이 기능은 특정 작업을 대단히 빠르게 할 수 있게 도움을 줍니다. 게임이 라이브 상태로 실행중인 동안에도 스크립트를 변경 할 수 있게 해 줍니다. 일반적인 사용 사례로는 게임플레이 매개변수들을 조정하거나 게임 실행중에 디버깅을 수행하는 사례 등이 있습니다.
+
+변경된 리소스를 리로드하려면,  **Edit ▸ Reload Resource** 메뉴를 선택하거나 해당 단축키를 누르면 됩니다.
+
+![Reloading resources](images/debugging/debugging_hot_reload.png)
+
+모든 스크립트 컴포넌트는 on_reload() 함수를 정의할 수 있습니다. 이 함수를 정의하면 스크립트가 에디터에서 게임으로 리로드 될 때 언제든지 호출 됩니다.
+
+```lua
+function on_reload(self)
+    -- 현재 속도 출력
+    print(self.velocity)
+
+    -- 속도를 0으로 설정
+    self.velocity = vmath.vector3()
+end
+```
+
+## Visual profiler
+Defold 엔진은 프로파일링 정보를 게임 실행중에 표시할 수도 있습니다. 이 기능은 디버깅이나 최적화를 할 때 큰 도움이 됩니다.
+
+```lua
+function on_reload(self)
+    -- 핫리로드 될 때 프로파일러를 켬
+    msg.post("@system:", "toggle_profile")
+end
+```
+
+프로파일러는 어플리케이션이 실행중일 때 실시간 정보를 표시합니다.
+
+![Visual profiler](images/debugging/debugging_profiling.png)
+
+## Web profiler
+게임이 실행되는 동안, 자세한 프로파일링 정보를 제공하는 웹기반 프로파일러에도 접속 할 수 있습니다. 이 기능은 데이터 지점들을 샘플링하여 더 자세히 분석할 수 있게 해 줍니다.
+
+프로파일러에 접속하기 위해서는:
+
+1. 대상 장치(target device)에서 게임을 시작함
+2. 웹브라우저를 열어 http://<장치의 IP address>:8002 로 접속함
+
+게임이 데스크탑 컴퓨터에서 실행중이라면, http://localhost:8002 주소로 프로파일러에 접속 할 수 있습니다. 대상 장치의 IP 주소는 **Project ▸ Target** 메뉴에서도 찾을 수 있습니다.
+
+![Web profiler](images/debugging/webprofiler_page.png)
+
+이 프로파일러는 4개의 섹션으로 나누어져 있으며 현재 샘플 데이터의 4가지 뷰로 각각 다르게 보여줍니다. 샘플 데이터를 업데이트 하려면, 상단에 **Capture** 버튼을 누르면 됩니다.
+
+### Frames overview
+프레임 오버뷰는 현재 샘플링된 20 프레임을 나란히 표시합니다. 각 바(bar)의 높이는 프레임에 소요된 시간을 나타냅니다. 왼쪽의 숫자는 현재 샘플 데이터의 한 프레임에서 보낸 최대 시간을 나타냅니다.
+
+![Frames overview](images/debugging/webprofiler_frames_overview.png)
+
+아래의 프레임 오버뷰는 프레임 데이터를 자세하게 보여줍니다. 오버뷰의 프레임 바를 클릭해서 데이터뷰에서 특정 프레임의 데이터를 나타낼 수 있습니다. 또한 클릭된 프레임 데이터의 프레임 타임차트(timechart)도 페이지 하단에 보여줍니다.
+
+### Frame data
+프레임 데이터 뷰는 현재 선택된 프레임을 자세히 세분화한 데이터의 테이블입니다. 이 뷰에서 각 엔진 스코프(scope)가 얼마나 많은 밀리초(milliseconds)를 소모했는지를 알 수 있으며(왼쪽) 스코프 내에 있는 샘플 지점(sample points)도 볼 수 있습니다(가운데). 오른편엔 카운터(counter) 테이블이 있는데, 샘플 데이터의 각 프레임마다 요청된 드로우 콜(draw calls) 수를 추적하기가 쉽습니다.
+
+![Frame data](images/debugging/webprofiler_frame_data.png)
+
+샘플 포인트 또는 카운터와 관련된 체크박스를 클릭하면 데이터를 아래 플롯에 추가할 수 있습니다.
+
+### Frames plot
+프레임 플롯 뷰는 X 축에는 프레임 수, Y 축에는 시간(밀리초)으로 된 프레임 데이터 테이블을 사용하여 모든 샘플링된 프레임의 플롯을 보여줍니다. 각 선택된 데이터 포인트는 프레임 데이터 테이블에 지정된 특정 색상으로 그려집니다.
+
+![Frames plot](images/debugging/webprofiler_frames_plot.png)
+
+### Frame time chart
+프레임 타임 차트는 선택된 프레임 동안 엔진이 소모한 시간을 아주 쉽게 조사할 수 있게 시각적으로 보여줍니다.
+
+![Frame timechart](images/debugging/webprofiler_frame_timechart.png)
+
+(일부 그래픽 에셋은 Kenney가 제작했습니다 : http://kenney.nl/assets)

docs/ko/manuals/extensions.md

@@ -0,0 +1,187 @@
+# Native extensions
+만약 Lua로는 충분하지 못한 외부 소프트웨어나 하드웨어와 로우 레벨로 커스텀 상호작용이 필요한 경우에는, Defold SDK는 C++로 익스텐션을 만들 수 있습니다. 네이티브 익스텐션의 일반적인 사용 사례로는 다음과 같습니다.
+
+* 예를 들면 모바일 카메라 같은 특정 하드웨어와 상호작용 하기
+* 광고 네트워크 API나 Luasocket을 사용할 수 있는 네트워크 API 같은 외부 로우 레벨 API와 상호작용 하기
+* 고성능 계산
+
+## The build platform
+Defold는 클라우드 기반 빌드 솔루션을 사용하여 네이티브 익스텐션에 대한 무설정 진입 지점(zero setup entry point)을 제공합니다. 게임 프로젝트에 추가된 네이티브 익스텐션은 일반적인 프로젝트 컨텐츠의 일부가 됩니다. 엔진의 특정 버전으로 빌드하거나 팀원에게 배포할 필요도 없으며 이 작업들은 자동으로 이루어집니다. 프로젝트를 빌드하거나 실행하려는 모든 팀원들은 모든 네이티브 익스텐션과 함께 특정 프로젝트 엔진 실행파일을 받을 수 있습니다.
+
+![Cloud build](images/extensions/cloud_build.png)
+
+## Project layout
+새 익스텐션을 만들기 위해서는 프로젝트 루트에 폴더를 하나 만들어야 합니다. 이 폴더에는 익스텐션과 관계된 모든 셋팅, 소스코드, 라이브러리, 리소스들을 포함시켜야 합니다. 이 익스텐션 빌더는 폴더 구조를 인식하고 모든 소스파일과 라이브러리를 수집합니다.
+
+![Project layout](images/extensions/layout.png)
+
+#### "ext.manifest"
+익스텐션 폴더에는 "ext.manifest" 파일이 있어야 합니다. 이 파일은 익스텐션 빌더에 의해 선택되는 YAML 형식의 파일입니다. 메니페스트 파일에는 최소한 익스텐션의 이름이 포함되어 있어야 합니다.
+#### src
+이 폴더에는 모든 소스코드 파일들이 있어야 합니다.
+#### include
+이 선택적(optional) 폴더에는 다른 포함 파일(include files)들이 있어야 합니다.
+#### lib
+이 선택적 폴더에는 익스텐션이 의존하는 모든 컴파일된 라이브러리들이 있어야 합니다. 라이브러리 파일들은 라이브러리가 지원하는 아키텍쳐가 무엇인지에 따라 플랫폼 또는 아키텍쳐-플랫폼 이름의 하위 폴더에 있어야 합니다. 지원되는 플랫폼은 ios, android, osx 이며 지원되는 아키텍쳐-플랫폼 쌍(arc-platform pairs)은 armv7-ios, arm64-ios, armv7-android, x86_64-osx 입니다.
+#### res
+이 선택적 폴더에는 익스텐션이 의존하는 모든 추가 리소스들이 있어야 합니다. 리소스 파일들은 "lib" 하위 폴더처럼 플랫폼 또는 아키텍쳐-플랫폼 이름의 하위 폴더에 있어야 합니다. common 이름의 하위폴더에는 모든 플랫폼에 공통적인 리소스 파일들을 포함시킬 수 있습니다.
+
+## A simple example extension
+아주 간단한 익스텐션을 개발해 봅시다. 우선, "myextension" 이라는 새 루트 폴더를 만들고 익스텐션의 이름이 있는 "ext.manifest" 파일을 추가해 봅시다.
+
+![Manifest](images/extensions/manifest.png)
+
+*ext.manifest*
+```yaml
+name: "MyExtension"
+```
+
+익스텐션을 구성하는 C++ 파일 한 개를 "myextension.cpp" 라는 이름으로 "src" 폴더에 생성합니다.
+
+Defold 에디터는 기본적으로 .cpp 파일을 열 수 없으므로 파일을 더블 클릭해서 해당 파일 타입에 사용되는 시스템 에디터를 사용합니다. 물론 해당 파일에 마우스 오른쪽 클릭해서  **Open With ▸ Text Editor** 메뉴를 선택해 내장된 텍스트 에디터를 사용해도 되지만, Defold는 C++ 파일을 지원하지 않으므로 최소한의 편집 기능만 사용 가능합니다.
+
+![C++ file](images/extensions/cppfile.png)
+
+익스텐션 소스 파일은 아래 코드를 포함합니다.
+
+*myextension.cpp*
+```cpp
+// Extension lib defines
+#define LIB_NAME "MyExtension"
+#define MODULE_NAME "myextension"
+
+// include the Defold SDK
+#include <dmsdk/sdk.h>
+
+static int Rot13(lua_State* L)
+{
+    int top = lua_gettop(L);
+
+    // 스택에서 문자열 파라미터 체크하고 가져오기
+    const char* str = luaL_checkstring(L, 1);
+
+    // 새 문자열 할당
+    int len = strlen(str);
+    char *rot = (char *) malloc(len + 1);
+
+    // 파라미터 문자열을 반복해서 rot13 문자열 생성하기
+    for(int i = 0; i <= len; i++) {
+        const char c = str[i];
+        if((c >= 'A' && c <= 'M') || (c >= 'a' && c <= 'm')) {
+            // A~M 사이의 char에 13 더하기
+            rot[i] = c + 13;
+        } else if((c >= 'N' && c <= 'Z') || (c >= 'n' && c <= 'z')) {
+            // N~Z 사이의 char에 13을 빼기
+            rot[i] = c - 13;
+        } else {
+            // 문자를 그대로 유지함
+            rot[i] = c;
+        }
+    }
+
+    // 회전된 문자열을 스택에 넣음
+    lua_pushstring(L, rot);
+
+    // 문자열 메모리 해제. Lua는 지금 복제본을 가지고 있음
+    free(rot);
+
+    // 스택에 하나의 아이템이 있음을 assert 함
+    assert(top + 1 == lua_gettop(L));
+
+    // 1 아이템 반환
+    return 1;
+}
+
+// Lua에 노출된 함수
+static const luaL_reg Module_methods[] =
+{
+    {"rot13", Rot13},
+    {0, 0}
+};
+
+static void LuaInit(lua_State* L)
+{
+    int top = lua_gettop(L);
+
+    // lua 이름을 등록하기
+    luaL_register(L, MODULE_NAME, Module_methods);
+
+    lua_pop(L, 1);
+    assert(top == lua_gettop(L));
+}
+
+dmExtension::Result AppInitializeMyExtension(dmExtension::AppParams* params)
+{
+    return dmExtension::RESULT_OK;
+}
+
+dmExtension::Result InitializeMyExtension(dmExtension::Params* params)
+{
+    // Init Lua
+    LuaInit(params->m_L);
+    printf("Registered %s Extension\n", MODULE_NAME);
+    return dmExtension::RESULT_OK;
+}
+
+dmExtension::Result AppFinalizeMyExtension(dmExtension::AppParams* params)
+{
+    return dmExtension::RESULT_OK;
+}
+
+dmExtension::Result FinalizeMyExtension(dmExtension::Params* params)
+{
+    return dmExtension::RESULT_OK;
+}
+
+
+// Defold SDK는 익스텐션 진입점을 셋팅하기 위해 매크로를 사용함
+//
+// DM_DECLARE_EXTENSION(symbol, name, app_init, app_final, init, update, on_event, final)
+
+DM_DECLARE_EXTENSION(MyExtension, LIB_NAME, AppInitializeMyExtension, AppFinalizeMyExtension, InitializeMyExtension, 0, 0, FinalizeMyExtension)
+```
+
+DM_DECLARE_EXTENSION 매크로는 익스텐션 코드에 다양한 진입점(entry points)을 선언하는데 사용됩니다. 이 간단한 예제에서는, "update"나 "on_event" 진입점이 필요하지 않으므로 대신 0 값을 매크로 인자값으로 보냅니다.
+
+이제 프로젝트를 빌드(**Project ▸ Build and Launch**)할 차례입니다. 이것은 익스텐션을 익스텐션 빌더에 업로드해서 새 익스텐션이 포함된 커스텀 엔진을 생성합니다. 만약 빌더에 에러가 발생하면 빌드 에러가 있는 대화창을 표시합니다.
+
+익스텐션을 테스트하려면, 게임 오브젝트를 생성해서 아래와 같은 테스트 코드가 있는 스크립트 컴포넌트를 추가해야 합니다.
+
+```lua
+local s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+local rot_s = myextension.rot13(s)
+print(rot_s) --> nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM
+```
+
+이제 끝입니다! 우리는 완전히 잘 동작하는 네이티브 익스텐션을 만들었습니다.
+
+## The ext.manifest file
+메니페스트 파일에는 익스텐션의 이름 외에도 특정 플랫폼의 compile flags, link flags, libs, frameworks 를 추가할 수 있습니다. 아래에 예제가 있습니다.
+
+*ext.manifest*
+```yaml
+name: "AdExtension"
+
+platforms:
+    arm64-ios:
+        context:
+            frameworks: ["CoreGraphics", "CFNetwork", "GLKit", "CoreMotion", "MessageUI", "MediaPlayer", "StoreKit", "MobileCoreServices", "AdSupport", "AudioToolbox", "AVFoundation", "CoreGraphics", "CoreMedia", "CoreMotion", "CoreTelephony", "CoreVideo", "Foundation", "GLKit", "JavaScriptCore", "MediaPlayer", "MessageUI", "MobileCoreServices", "OpenGLES", "SafariServices", "StoreKit", "SystemConfiguration", "UIKit", "WebKit"]
+            flags:      ["-stdlib=libc++"]
+            linkFlags:  ["-ObjC"]
+            libs:       ["z", "c++", "sqlite3"]
+
+    armv7-ios:
+        context:
+            frameworks: ["CoreGraphics", "CFNetwork", "GLKit", "CoreMotion", "MessageUI", "MediaPlayer", "StoreKit", "MobileCoreServices", "AdSupport", "AudioToolbox", "AVFoundation", "CoreGraphics", "CoreMedia", "CoreMotion", "CoreTelephony", "CoreVideo", "Foundation", "GLKit", "JavaScriptCore", "MediaPlayer", "MessageUI", "MobileCoreServices", "OpenGLES", "SafariServices", "StoreKit", "SystemConfiguration", "UIKit", "WebKit"]
+            flags:      ["-stdlib=libc++"]
+            linkFlags:  ["-ObjC"]
+            libs:       ["z", "c++", "sqlite3"]
+```
+
+## Known issues
+네이티브 익스텐션 기능은 알파(alpha) 상태이므로, 아직 모든 기능이 준비되지는 않았습니다.
+
+* Platforms: 현재는 macOS, iOS, Android 익스텐션 빌드만 지원합니다.
+* Android 는 .java 와 .jar archives 에 대한 지원이 부족합니다.
+* Editor: 에디터 통합(editor integration). 빌드 프로세스가 표시되지 않고 에러 리포팅 기능도 아직 몇몇 기능만 지원됩니다.
+* Debugging: 현재, iOS에서 빌드하는 경우, .dSYM 파일이 결과 빌드에 포함되고 있지 않습니다.

docs/ko/manuals/facebook.md

@@ -0,0 +1,145 @@
+
+# Facebook
+Facebook API 는  iOS, Android, HTML5 게임을 위해 규격화된 방법으로 Facebook의 게임 연동 기능과 상호작용 할 수 있게 해 줍니다.
+
+Defold Facebook API 는 다양한 플랫폼에서 돌아가는 Facebook API를 iOS, Android, HTML5 (Facebook Canvas를 통해서)에서 동일하게 동작하게끔 통일된 함수들을 제공합니다. 게임에서 Facebook 연동을 시작하려면 Facebook 계정이 필요합니다.
+
+> Defold 1.2.92 에서 Facebook API가 새로운 방법으로 재설계 되었습니다. 이전 API도 여전이 작동하므로 크리티컬한 변경사항은 없습니다. 하지만 예전 API는 새로운 어플리케이션에는 사용하지 않는 것이 좋습니다.
+
+## Registering as a Facebook developer
+Facebook 연동 개발을 하려면 Facebook developer에 가입해야 합니다. 여기서 Defold 게임과 커뮤니케이션 할 수 있는 Facebook 어플리케이션을 생성할 수 있습니다.
+
+* [Facebook for developers](https://developers.facebook.com/)로 이동합니다.
+* Facebook 계정으로 로그인 합니다.
+* 지침에 따라 개발자 계정을 등록하고 확인합니다.
+
+![Register as a developer](images/facebook/register_dev.png)
+
+![developer](images/facebook/register_verify.png)
+
+## Creating a Facebook app
+다음 단계는 Facebook application을 생성하는 것입니다. 구석에 My Apps 메뉴를 열어서 생성한 앱 목록을 볼 수 있습니다. 여기서 Add a New App 을 선택합니다.
+
+![Add new app](images/facebook/add_new_app_menu.png)
+
+타겟 플랫폼 선택화면이 나타나면 **basic setup** 를 클릭해서 마법사(wizards)를 스킵합니다.
+
+> 마법사를 통해 제공되는 대부분의 정보는 Defold의 개발과는 무관합니다. 특히 일반적으로  "Info.plist" 또는 "AndroidManifest.xml" 을 직접 편집할 필요가 없습니다.
+
+![Add new app platform](images/facebook/add_new_app_platform.png)
+
+앱 대쉬보드에서는 플랫폼 설정을 쉽게 추가, 삭제, 변경할 수 있습니다. 이제 앱의 이름을 지정하고 **Display Name**, **Namespace**, **Category** 를 선택할 수 있습니다. 다시 말하지만, 이 모든 값들은 앱 대쉬보드에서 수정해야 합니다. 이 과정을 마치면 Facebook은 고유한 앱 식별자로 앱을 생성합니다. **App ID** 는 특정 앱을 식별한 이후로는 변경하는 것이 불가능합니다.
+
+![New app id](images/facebook/new_app_id.png)
+
+![App dashboard settings](images/facebook/add_platform.png)
+
+**Settings** 탭을 클릭해서 숫자로 된 **App ID**를 확인합니다. 이 식별자는 Defold 게임의 [project settings](project%20settings)에 필요한 값입니다. 불행히도 이 설정은 에디터에서는 숨겨져 있지만(곧 변경될 예정임), "game.project"에 마우스 오른쪽 클릭해서 **Open With ▸ Text Editor** 메뉴를 선택해서 식별자를 쉽게 추가할 수 있습니다.
+
+![Open project settings with](images/facebook/project_open_with.png)
+
+[facebook] 섹션에 **App ID**에 해당하는 appid=456788687846098 를 추가합니다. 숫자가 맞는지 확인하고 파일을 저장합니다.
+
+![Game project](images/facebook/game_project.png)
+
+이제, Facebook 앱 페이지의 **Settings** 탭으로 돌아와서 **\+ Add Platform** 를 클릭해서 앱에 새 플랫폼을 추가합니다. 각 플랫폼 별로 채워야하는 설정 항목들이 있습니다.
+
+![Select platform](images/facebook/select_platform.png)
+
+## iOS
+iOS의 경우 "game.project"에 설정한 **bundle_identifier** 를 Bundle ID에 지정해야 합니다.
+
+![iOS settings](images/facebook/settings_ios.png)
+
+## Android
+Android의 경우 **Google Play Package Name**에 "game.project"에서 설정한 **package** 식별자를 지정해야 합니다.  또한 인증서의 해쉬값을 생성해서 **Key Hashes** 필드에 입력해야 합니다. openssl 을 사용하여  "certificate.pem"에서 해쉬를 생성할 수 있습니다.
+
+```
+$ cat certificate.pem | openssl x509 -outform der | openssl sha1 -binary | openssl base64
+```
+
+(서명 파일을 생성하는 자세한 방법은 Android 매뉴얼의 [Creating certificates and keys](android#Creating-certificates-and-keys)에서 참고 바랍니다.)
+
+![Android settings](images/facebook/settings_android.png)
+
+## Facebook Canvas
+HTML5 게임의 경우에는 작업과정이 약간 다릅니다. Facebook은 어딘가로부터 게임 컨텐츠를 액세스 할 수 있게 해야합니다. 여기 두 가지 옵션이 있습니다.
+
+![Facebook Canvas settings](images/facebook/settings_canvas.png)
+
+1. Facebook의 **Simple Application Hosting** 를 사용합니다. **Yes**를 클릭해서 페이스북이 관리하는 호스팅을 선택합니다. **uploaded assets** 를 선택해서 hosted asset manager를 엽니다.
+![Simple hosting](images/facebook/simple_hosting.png)
+"HTML5 Bundle"을 선택합니다:
+![HTML5 bundle](images/facebook/html5_bundle.png)
+HTML5 bundle을 .7z 또는 .zip 으로 압축해서 Facebook에 업로드 합니다. **Push to production** 를 클릭해서 게임 서비스를 시작합니다.
+
+2. Facebook 호스팅의 대안으로는 HTTPS 를 통해 게임을 서비스하는 특정 서버로 HTML5 bundle 을 업로드 하는 방법이 있습니다. **Secure Canvas URL**를 게임의 URL로 설정합니다.
+
+이제, **Canvas Page**로 제공된 Facebook URL 을 통하여 게임이 작동하게 됩니다.
+
+## Testing the setup
+다음의 기본적인 테스트를 사용하여 올바르게 설정되었는지 확인할 수 있습니다.
+
+1. 새 게임 오브젝트를 만들어 새 스크립트 컴포넌트를 추가함
+2. 스크립트 파일에 아래 코드를 입력함
+
+```lua
+local function get_me_callback(self, id, response)
+    -- response 테이블은 모든 응답 데이터를 포함하고 있음
+    pprint(response)
+end
+
+local function fb_login(self, data)
+    if data.status == facebook.STATE_OPEN then
+        -- 로그인에 성공하면 HTTP graph API를 통해 "me" 데이터를 읽어보자
+        local token = facebook.access_token()
+        local url = "https://graph.facebook.com/me/?access_token=" .. token
+        http.request(url, "GET", get_me_callback)
+    elseif data.status == facebook.STATE_CLOSED_LOGIN_FAILED then
+        -- 로그인 실패시 뭔가 처리하자...
+    end
+    if data.error then
+        -- 에러 발생
+    else
+        -- 에러 없음
+    end
+end
+
+function init(self)
+    -- 읽기 권한으로 로그인하기
+    local permissions = { "public_profile", "email" }
+    facebook.login_with_read_permissions(permissions, fb_login)
+end
+```
+
+이 간단한 테스트를 실행하면 콘솔창에 아래와 같은 내용이 표시됩니다.
+
+```
+DEBUG:SCRIPT:
+{
+  status = 200,
+  headers = {
+    connection = keep-alive,
+    date = Fri, 04 Nov 2016 13:54:33 GMT,
+    etag = "0725a4f703fe6af27da183cfec0bb22637e331e0",
+    access-control-allow-origin = *,
+    content-length = 53,
+    expires = Sat, 01 Jan 2000 00:00:00 GMT,
+    content-type = text/javascript; charset=UTF-8,
+    x-fb-debug = Pr1qUssb8Xa3x3r1t913hHMdefh69DSYYV5vcxeOB7O33mcfShIw+r7BoLpn147I2wzLF2CZRTpnR3/VYOtFpA==,
+    facebook-api-version = v2.5,
+    cache-control = private, no-cache, no-store, must-revalidate,
+    pragma = no-cache,
+    x-fb-trace-id = F03S5dtsdaS,
+    x-fb-rev = 2664414,
+  }
+  response = {"name":"Max de Fold ","id":"14159265358979323"},
+}
+```
+
+* 전체 Defold Facebook API 는 [Facebook reference documentation](http://www.defold.com/ref/facebook) 에 문서화 되어 있습니다.
+* Facebook Graph API 는 https://developers.facebook.com/docs/graph-api 에 문서화 되어 있습니다.
+
+## Development caveats
+개발중에는 dev application으로 사용하는 것이 매우 편리합니다. 불행히도 Facebook API는 번들링 된 "Info.plist" 파일이 구성되어야 하는 방법에 따라 dev 앱에서 아직 동작하지 않습니다. 하지만 모든 디버그 번들은 dev 앱으로 동작하므로, 다른 해결책으로는 적절한 Facebook 프로젝트 설정으로 게임을 빌드하고, 장치에 넣고, 실행중인 게임에 연결하고, 평상시 처럼 데이터를 에디터에서 스트림하면 됩니다.
+

docs/ko/manuals/factory.md

@@ -0,0 +1,84 @@
+# Factory components
+팩토리 컴포넌트는 오브젝트 풀(pool of objects)에서 실행중인 게임으로 게임오브젝트를 동적으로 스폰하는데 사용됩니다. 펙토리 컴포넌트를 게임 오브젝트에 추가하고, **Prototype** 속성에 특정 게임 오브젝트 파일을 지정하면 설계도면 찍어내듯이 새 게임 오브젝트를 찍어낼 수 있습니다.
+
+![Factory component](images/factory/factory_component.png)
+
+![Factory component](images/factory/factory_collection.png)
+
+게임 오브젝트 생성을 트리거 하기 위해서는 factory.create()를 호출하면 됩니다.
+
+*factory.script*
+```lua
+local p = go.get_position()
+p.y = vmath.lerp(math.random(), min_y, max_y)
+local component = "#star_factory"
+factory.create(component, p)
+```
+
+![Spawned game object](images/factory/factory_spawned.png)
+
+factory.create() 함수는 5개의 파라메터를 가집니다.
+
+#### url
+새 게임오브젝트를 스폰하는 펙토리 컴포넌트의 아이디
+#### [position]
+(선택) 새 게임 오브젝트의 월드 포지션(world position). vector3 형식이며, 포지션을 정하지 않으면 게임오브젝트가 펙토리 컴포넌트의 위치에 스폰됨
+#### [rotation]
+새 게임 오브젝트의 월드 로테이션(world rotation). quat(쿼터니온) 형식임
+#### [properties]
+게임 오브젝트와 초기화 되는 스크립트 속성값의 Lua 테이블. 자세한 내용은 [Script properties](Script%20properties) 매뉴얼 참고
+#### [scale]
+스폰된 게임오브젝트의 스케일(scale). 0보다 큰 숫자로 입력하면 모든 축(axis)에 동일한 사이즈로 변경되며, vector3로 입력하면 축마다 다른 크기로 스케일링 할 수 있음
+
+예제:
+
+*factory.script*
+```lua
+local p = go.get_position()
+p.y = vmath.lerp(math.random(), min_y, max_y)
+local component = "#star_factory"
+-- 회전 없이 두배의 스케일로 스폰함. star의 score를 10으로 설정함
+factory.create(component, p, nil, { score = 10 }, 2.0)                           [1]
+```
+**[1].** star 게임 오브젝트의 "score" 속성을 설정함
+
+*star.script*
+```lua
+go.property("score", 1)                                                                         [1]
+
+local speed = -240
+
+function update(self, dt)
+    local p = go.get_position()
+    p.x = p.x + speed * dt
+    if p.x < -32 then
+        go.delete()
+    end
+    go.set_position(p)
+end
+
+function on_message(self, message_id, message, sender)
+    if message_id == hash("collision_response") then
+        msg.post("main#gui", "add_score", {amount = self.score})         [2]
+        go.delete()
+    end
+end
+```
+
+**[1].** "score" 스크립트 속성이 기본값과 함께 정의됨
+
+**[2].** "score" 스크립트 속성을 "self"에 저장된 값처럼 참조함
+
+![Spawned game object with property and scaling](images/factory/factory_spawned2.png)
+
+> 현재 Defold는 충돌 모양(collision shape)의 비규격 스케일링(non uniform scaling)을 지원하지 않습니다. vmath.vector3(1.0, 2.0, 1.0) 와 같은 비규격 스케일링 값을 넘기면 스프라이트는 제대로 변형되지만 충돌 모양은 제대로 변형되지 않습니다.
+
+## Instance limits
+**Project Settings**에 있는 **max_instances** 속성은 게임 월드(게임 시작시 로드된 main.collection을 비롯해 collection proxy를 통해 로드된 모든 월드)에 존재할 수 있는 게임 오브젝트 인스턴스의 총 수량을 제한합니다. 게임 월드에 존재하는 모든 게임 오브젝트는 에디터에서 직접 배치하던지 스크립트로 스폰하던지와 상관없이 제한된 수량 만큼 카운트 됩니다.
+
+![Max instances](images/factory/factory_max_instances.png)
+
+그러므로 만약 **max_instances**를 1024로 설정하고 메인 컬렉션에 24개의 게임오브젝트를 수동으로 배치했다면, 1000개의 게임오브젝트를 추가로 스폰할 수 있게 됩니다. 그리고 게임오브젝트를 삭제하면, 삭제한 만큼의 인스턴스를 추가 생성할 수 있습니다.
+
+## Pooling of game objects
+스폰한 게임 오브젝트를 풀(pool)에 저장했다가 재사용하는 것은 좋은 방법인 듯 하지만 성능상의 이유로 이를 자제 하는것이 좋습니다. 게임오브젝트를 삭제하고 새로 스폰하는 것이 풀링을 하는 것보다 더 빠릅니다(때로는 더 깔끔함).

docs/ko/manuals/font.md

@@ -0,0 +1,96 @@
+# Font files
+폰트는 GUI 씬(GUI scene)에서 라벨 컴포넌트(label component)와 텍스트 노드(text node)를 렌더링 하는데 사용됩니다. 이 매뉴얼은 Defold가 폰트를 다루는 방법과 게임화면에 쓰일 폰트를 가져오는 방법에 대해 설명합니다.
+
+폰트 파일은 TrueType, OpenType, BMFont 포멧을 사용할 수 있으며 Defold가 렌더링 할 수 있도록 그래픽형식의 포멧으로 자동으로 변환합니다. 비트맵(bitmap)과 디스턴스 필드(distance field) 두 가지의 렌더링 기술이 있으며 각각 장단점이 있습니다.
+
+## Creating a font
+Defold에서 사용할 폰트를 만들려면, **File > New > Font File** 메뉴를 선택해서 새 폰트파일을 생성할 수 있습니다. (혹은 **Project Explorer**에서 마우스 오른쪽 버튼 눌러서 파일 생성)
+
+![Create font](images/font/fonts_create.png)
+
+또한 Defold 프로젝트로 폰트를 임포트 해야합니다. TrueType이나 OpenType (혹은 BMFont, 아래 참고)  파일을 **Project Explorer**의 원하는 위치에 드래그-앤-드롭 하면 됩니다.
+
+> 폰트의 그림자 렌더링은 현재 성능상의 이유때문에 기본적으로 비활성화 되어 있습니다. 필요한 경우엔 그림자를 렌더링하는 커스텀 쉐이더를 만들어 쓰면 됩니다(성능상 비용이 조금 들게됨). 앞으로 Defold는 사용된 기능을 기반으로 적당한 쉐이더를 선택할 수 있게 될 것입니다.
+
+#### font
+임포트한  TTF, OTF, .fnt 파일(파일을 찾으려면 [...] 버튼 클릭)을 이 속성에 설정하면 에디터는 즉시 폰트 데이터를 생성하고 폰트 에디터에서 미리보기를 보여줍니다.
+#### material
+폰트를 렌더링하는데 사용되는 메터리얼. 디스턴스 필드 폰트(distance field font)나 비트맵 폰트(BMFont)를 사용하려는 경우 이 값을 변경해야 합니다. (자세한 내용은 아래 참고)
+#### size
+픽셀단위의 문자(glyph) 크기
+#### antialias
+비트맵으로 구울(bake)때 안티알리아싱을 적용할 단위. 0이면 픽셀 퍼펙트(pixel perfect)로 폰트를 렌더링 합니다.
+#### alpha
+0.0~1.0 까지의 알파 채널 값. 0.0은 투명(transparent)하고 1.0은 불투명(opaque)함
+#### outline_alpha
+0.0~1.0 까지의 외곽선의 알파 채널 값
+#### outline_width
+픽셀단위의 외곽선 두께. 0으로 설정하면 외곽선 없음.
+#### shadow_alpha
+0.0~1.0 까지의 그림자 알파 채널 값
+#### shadow_blur
+픽셀단위의 그림자의 블러 반경(blur radius)
+#### shadow_x
+그림자의 가로 오프셋(horizontal offset)
+#### shadow_y
+그림자의 세로 오프셋(vertical offset)
+#### extra_characters
+기본적으로 폰트는 ASCII의 인쇄 가능한 문자(char code 32~126)들을 포함하고 있습니다. 이외의 문자를 더 추가하려면 이 속성에 추가할 문자를 입력하면 됩니다.
+#### output_format
+이 속성은 생성된 폰트의 타입을 제어합니다.
+
+* TYPE_BITMAP: 폰트가 OTF나 TTF 파일인 경우에, 임포트한 폰트를 비트맵 데이터를 사용하여 텍스트 노드(text node)를 렌더링하는 폰트 시트 텍스쳐(font sheet texture)로 변환합니다. 컬러 채널은 폰트의 face shape, outline, shadow 같은 폰트의 여러 측면을 인코딩 하는데 사용되어 글꼴의 원시 모양을 red 채널로, outline은 green 채널로, shadow는 blue 채널로 미리보기를 보여 줍니다. 비트맵 타입 폰트의 픽셀의 밀도(density)는 고정되어 있으므로 정해진 사이즈 혹은  작은 사이즈로 보여주는 경우엔 깔끔하게 보일 것입니다. 비트맵 폰트는 아주 빠르게 렌더링 되지만 사이즈의 제한이 있으므로 스케일업 하는 경우엔 뭉개짐 현상이 나타납니다.
+
+* TYPE_DISTANCE_FIELD: 임포트한 폰트를 픽셀 데이터를 사용하여 스크린 픽셀(screen pixel)이 아니라 폰트 가장자리의 거리(distances to the font edge)로서 나타내는 폰트 시트 텍스쳐(font sheet texture)로 변환합니다.
+
+#### all_chars
+이 속성을 true로 설정하면 원본 폰트 파일의 모든 문자가 출력에 포함됩니다.
+#### cache_width
+문자 캐쉬 비트맵(glyph cache bitmap)의 넓이를 제한하려면 이 값을 설정하십시오. 엔진이 텍스트를 렌더링할 때, 먼저 캐쉬 비트맵에서 문자(glyph)를 찾게 되는데, 캐쉬에 해당 문자가 존재하지 않는다면 렌더링하기 전에 캐쉬에 문자를 추가합니다. 캐쉬 비트맵이 너무 작아서 엔진이 렌더링 할 수 없는 경우 에러(ERROR: RENDER: Out of available cache cells! Consider increasing cache_width or cache_height for the font.)가 발생합니다. 이 값을 0으로 설정하면 캐쉬 사이즈가 자동적으로 설정됩니다.
+
+#### cache_height
+문자 캐쉬 비트맵(glyph cache bitmap)의 높이를 제한하려면 이 값을 설정하십시오.  이 값을 0으로 설정하면 캐쉬 사이즈가 자동적으로 설정됩니다.
+
+> ASCII의 출력 가능한 문자들: space ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~
+
+## Bitmap BMFonts
+생성된 비트맵 이외에도 Defold는 미리 구워진(prebaked) 비트맵인 "BMFont" 포멧의 폰트를 지원합니다. 이 폰트는 모든 문자 모양이 있는 PNG 폰트 시트(PNG font sheet)로 구성됩니다. 또한 **.fnt** 파일에는 사이즈와 커닝(kerning) 정보 뿐만아니라 각 문자 모양을 시트에서 찾기 위한 정보가 포함되어 있습니다.
+
+이 폰트 타입은 TrueType 이나 OpenType 폰트 파일에서 생성된 비트맵 폰트에 비해 성능이 좋지는 않지만, 임의의 그래픽이나 컬러 효과, 그림자를 넣어 원하는 대로 꾸밀 수 있습니다.
+
+Defold 프로젝트에 **.fnt**와 **.png** 파일을 추가해 보세요. 이 두 파일은 같은 폴더에 있어야 합니다. 새 폰트 파일을 만들고 **font** 속성값으로 **.fnt** 파일을 지정하고 **output_format** 속성을 "TYPE_BITMAP"으로 설정하세요. Defold는 비트맵을 생성하지 않는 대신 당신이 추가한 PNG 파일을 사용합니다.
+
+> BMFont 를 만들기 위해서는 전용 툴을 사용해야 합니다. 여기 여러 옵션이 있습니다.
+* Bitmap Font Generator, AngelCode에 의해 제공되는 Windows 전용 툴
+* Shoebox, Windows와 MacOS를 위한 무료 Adobe Air 기반의 앱
+* Hiero, Java 기반의 오픈소스
+* Glyph Designer, 71 Squared의 유료 MacOS 툴
+* bmGlyph, Sovapps의 유료 MacOS 툴
+
+![BMFont](images/font/fonts_bmfont.png)
+
+## Distance field fonts
+디스턴스 필드(distance field) 폰트를 만들기 위해서는, **output_format** 속성에 "TYPE_DISTANCE_FIELD"를 선택하면 됩니다. 그러면 폰트로부터 디스턴스 필드 맵(distance field map)을 생성합니다. 엔진이 폰트를 렌더링하게되면, 이 디스턴스 데이터를 해석하여 날카로운 폰트의 가장자리(sharp font edge)를 만들어주는 특수한 쉐이더를 필요로 합니다. 디스턴스 필드 폰트는 비트맵 폰트에 비해 많은 성능을 소모하지만 글자의 사이즈를 조절하는데 매우 유연합니다.
+
+![Distance field font](images/font/fonts_distance_field.png)
+
+이 폰트를 만들 경우(혹은 화면에 렌더링 될 때 폰트가 알맞은 쉐이더를 사용하지 않을 경우)에는 **material** 속성값을 "builtins/fonts/font-df.material"(혹은 디스턴스 필드 데이터를 다룰 수 있는 다른 메터리얼)로 변경해야 합니다. 
+
+![Distance field font material](images/font/fonts_distance_field_material.png)
+
+## Artifacts and best practices
+일반적으로, 비트맵 폰트는 스케일링 없이 렌더링 될 경우엔 최선의 선택입니다. 비트맵 폰트는 디스턴스 필드 폰트보다 화면에 빠르게 렌더링 됩니다.
+
+디스턴스 필드 폰트(Distance field font)는 폰트사이즈를 키울(upscaling) 경우에 아주 좋습니다. 반면 비트맵 폰트는 단지 픽셀로 된 이미지 이기 때문에 폰트 사이즈가 증가할 경우 픽셀의 크기도 커지게 되어 결과적으로 울퉁불퉁한 모양(blocky artifacts)이 됩니다. 아래는 48픽셀 크기의 폰트를 약 8배 정도 스케일-업 한 예제입니다.
+
+![Font type comparison](images/font/fonts_comparison.png)
+
+스케일-다운하면, 상황은 반대가 됩니다. 픽셀 텍스쳐는 작아지면 렌더링 하드웨어에 의해서 안티알리아싱 처리됩니다. 아래는 위와 같은 48픽셀 크기의 폰트를 절반 크기로 줄인 예제입니다.
+
+![Font type comparison, scale down](images/font/fonts_comparison_scaledown.png)
+
+디스턴스 필드 폰트는 특정 상황에서 또 다른 유형의 이상현상(artifacts)을 만들어 냅니다. 만약 폰트 모양에 아주 얇은 선이 있을 경우 이 폰트를 작은 사이즈(**size** 속성)로 렌더링 하면, 디스턴스 필드 텍스쳐가 문자 모양에 중요한 점을 표현하는데 데이터가 충분하지 않으므로 아마 아래와 같이 렌더링 될 것입니다.
+
+![Thin line artifacts](images/font/fonts_thin_line_artifacts.png)
+
+이 문제를 해결하려면, 더 큰 사이즈로 폰트를 만드시기 바랍니다.

docs/ko/manuals/gui-clipping.md

@@ -0,0 +1,51 @@
+# Clipping
+텍스쳐나 텍스트를 사용한 GUI 노드는 그래픽을 GUI에 추가하지만 때로는 화면의 그래픽 일부분을 제거하거나 특정 부분을 보여주는 마스크 기능이 필요한 경우가 있습니다. 이 메뉴얼은 이를 구현하는 방법을 설명합니다.
+
+예를 들어, 게임에서 플레이어가 자신의 방향을 잡기 위한 미니맵이 있는 HUD 요소를 화면에 생성해야 한다고 칩시다.
+
+![Minimap HUD](images/clipping/clipping_minimap.png)
+
+클리핑(clipping)과 함께 파이 노드(pie node)를 사용하면 미니맵을 매우 쉽게 만들 수 있습니다.
+
+![Making the minimap](images/clipping/clipping_making_minimap.png)
+
+1. pie 노드 추가. 맵을 위한 "열쇠구멍" 역할을 하게됨
+2. box 노드를 추가하고 맵 텍스쳐를 반영함
+3. box 노드를 pie노드의 자식노드로 지정함
+4. pie 노드의 **Clipping** 프로퍼티를 "Stencil"로 설정함
+
+![Clipping preview](images/clipping/clipping_preview.png)
+
+이제 부모 노드는 자식 노드에 대한 "열쇠구멍" 역할을 하게 되어 부모 클리핑 노드에 의해 바인딩 된 그래픽만 표시되므로 부모 노드는 맵의 그래픽 외부 영역을 정의하게 됩니다. 따라서 맵 노드를 자유롭게 움직여도 부모 영역 내에 있는 부분이 표시되게 됩니다.
+
+클리핑은 box노드와 pie 노드에 반영할 수 있으며 Text 노드는 다른 노드와 클리핑 할 수 없습니다. 클리핑에는 두 가지 타입이 있는데 클리퍼의 모양을 그리는 **Visible clipper**와 클리핑 마스크에 미치는 영향을 반전시키는 **Inverted clipper**가 있습니다. (자세한 내용은 아래 참고)
+
+![Clipping properties](images/clipping/clipping_properties.png)
+
+Stencil 클리핑은 box 노드와 pie 노드에 반영할 수 있는데, Stencil에는 몇 가지 제한사항이 있습니다.
+
+1. stencil clippers의 총 수는 256개를 초과할 수 없음
+2. stencil 자식 노드의 최대 중첩 깊이(nesting depth)는 8단계임(stencil 클리핑 카운트를 사용한 노드만)
+3. stencil 형제 노드의 최대 수는 127개임. stencil 계층구조 아래의 각 레벨의 최대 제한은 절반으로 줄어듬
+4. Inverted 노드는 비용이 많이 듬. 8개의 inverted clipping 노드가 한계이고 non-inverted clipping 노드의 최대치의 절반이 됨
+5. Stencils은 텍스쳐가 아닌 노드의 지오메트리로부터 stencil 마스크를 렌더링함. **Inverted clipper** 프로퍼티를 설정해서 마스크를 반전 시킬 수 있음
+
+## Stencil mask
+스텐실 클리핑이 어떻게 동작하는지 이해하기 위해, 스텐실의 계층이 어떻게 개별 클리핑의 모양을 그 계층구조 하에서 전체 마스크로 반영하는지 상상해 보는 것이 좋습니다. 클리핑 노드의 마스크 세트는 해당 노드의 자식들로 상속되며 자식 노드들은 절대 마스크를 확장하지 않고 오직 클리핑만 합니다. 구체적인 예제를 살펴 봅시다.
+
+![Clipping hierarchy](images/clipping/clipping_hierarchy.png)
+
+hexagon 과 square 모형 둘 다 스텐실 클리퍼를 설정합니다. **Inverted clipper** 프로퍼티를 설정하면 해당 노드로 상속된 마스크를 반전 시킵니다. 위의 계층구조에서 normal clippers와 inverted clippers를 사용하여 4가지의 조합이 가능합니다.
+
+![Stencil masks](images/clipping/clipping_stencil_masks.png)
+
+만약 인버트된 노드 아래에 또 **Inverted clipper**로 설정된 노드가 있다면, 자식 노드에 의해 마스크된 영역이 인버트됩니다. inverted clippers 노드를 각각 자식노드로 엮는 방법으로 노드에 여러개의 구멍을 낼 수도 있습니다.
+
+![Two inverters cutting a node](images/clipping/clipping_two_inverters.png)
+
+## Layers
+레이어는 노드의 렌더링 순서(일괄 처리(batch))를 제어할 수 있습니다. 레이어와 클리핑 노드를 사용하면 일반적인 레이어 순서가 무시(override) 됩니다. 클리핑 순서는 레이어 순서보다 우선하게 되는데, 즉 노드가 속한 레이어에 관계 없이, 노드 계층에 따라 클리핑 됩니다. 레이어는 오직 그래픽의 그리기 순서에만 영향을 미치며, 더 나아가서 클리핑 노드에 설정된 레이어는 해당 클리퍼 계층의 그리기 순서에만 영향을 미칩니다.
+
+예를 들어, 안쪽 그림자 텍스쳐(inner shadow texture)가 있는 "window_and_shadow" 라는 클리퍼 노드가 있다고 가정해 봅시다. 이 노드의 **Visible clipper** 프로퍼티를 체크하고 "layer2"로 설정해서 "layer0"의 "map" 노드와 클리핑을 연결합니다. 이 클리퍼 텍스쳐는 "map" 자식노드의 위에서 렌더링됩니다. "map"에 설정된 레이어 혹은 "window_and_shadow" 설정된 레이어는 "blue_box" ("layer2") 와 "orange_box" ("layer1") 에 관련된 렌더링 순서에 영향을 주지 않습니다. 만약 "blue_box" 와 "orange_box" 에 관련해서 "window_and_shadow" 의 렌더링 순서를 변경하려면, 노드 트리의 순서를 변경하면 됩니다.
+
+![Layers and clipping](images/clipping/clipping_layers.png)

docs/ko/manuals/gui-pie.md

@@ -0,0 +1,25 @@
+# Pie nodes
+Pie 노드는 원형 또는 타원형 오브젝트를 생성하는데 사용됩니다. 간단한 형태로, pie 노드는 노드 바운딩 박스 안에서 원형 혹은 타원형으로 간단하게 표시됩니다. 넓이와 높이가 같으면 원의 지름 값으로 사용되며 넓이와 높이가 다르면 노드는 수직확장을 위해 높이값을, 수평확장을 위해 넓이 값을 사용합니다. 노드의 텍스쳐 설정은 일직선(straight)으로 반영되며 이 텍스쳐의 모서리는 노드의 바운딩 박스의 모서리와 상호 연관되게 됩니다.
+
+![Pie node](images/gui/gui_pie_create.png)
+
+Pie 노드는 다양한 모양을 만드는데 사용되는 프로퍼티들을 가지고 있습니다. 이 모든 프로퍼티는 프로그래밍 방식 ([GUI API documentation](http://www.defold.com/ref/gui/) 참고)으로 변경할 수 있으며 몇몇은 애니메이션 처리가 가능합니다.
+
+![Pie properties](images/gui/gui_pie_properties.png)
+
+#### Inner radius
+X 축을 따라 표시된 노드의 내부 반지름(inner radius)
+#### Outer bounds
+노드를 외부 반지름("Ellipse")으로 확장하거나 바운딩박스("Rectangle")로 확장함
+#### Perimeter vertices
+노드를 360도 둘레로 둘러싸는데 필요한 꼭지점(vertex)의 수로 표현되며, 원형 모양을 그리는데 사용되는 세그먼트(segment)의 수.
+#### Pie fill angle
+파이의 색상을 얼마나 채울지 결정. 오른쪽에서 시작해서 반 시계 방향으로 표시됨.
+
+![Radius and angle](images/gui/gui_pie_radius_angle.png)
+
+**Outer bounds**는 모양(shape)을 바운딩 박스까지 확장합니다. **Inner radius** 와 **Pie fill angle**를 함께 사용하면 꽤 복잡한 모양을 만들 수 있습니다.
+
+![Rectangle bounds](images/gui/gui_pie_rectangular.png)
+
+![Rectangle bounds and angle](images/gui/gui_pie_rectangular_angle.png)

docs/ko/manuals/gui-spine.md

@@ -0,0 +1,58 @@
+# GUI Spine nodes
+게임 오브젝트에서 뿐만 아니라 GUI 애니메이션에서도 스파인 본 애니메이션을 사용할 수 있습니다. 이 매뉴얼은 GUI 씬에서 스파인 애니메이션 데이터를 임포트하는 방법을 설명합니다.
+
+> 현재, 스파인 노드는 스파인 이벤트를 지원하지 않습니다. **SpineModel** 게임 오브젝트는 애니메이션 타임라인의 이벤트를 포함하고 게임오브젝트에 메세지를 전송할 수 있지만 스파인 노드에서는 지원되지 않습니다.
+
+임포트된 스파인 본 애니메이션(Spine bone animation)은 게임 오브젝트 뿐 아니라 GUI 씬에서도 사용할 수 있습니다(**SpineModel** 컴포넌트를 통해서). Defold에서 스파인 본 애니메이션을 동작시키기 위해, 먼저 애니메이션 데이터를 임포트하고 스파인 씬(Spine Scene) 리소스를 설정해야 합니다. 이를 위한 설명은 [Spine animation](Spine animation) 문서를 참고하시기 바랍니다.
+
+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/gui-templates.md

@@ -0,0 +1,40 @@
+# Templates
+GUI 템플릿은 "prefabs" 혹은 공유 템플릿을 기반으로 시각적 GUI 컴포넌트를 재사용하기 위한 강력하고 간단한 메커니즘을 제공합니다. 이 메뉴얼은 템플릿을 어떻게 사용하는지 설명합니다.
+
+GUI 템플릿은 다른 컬렉션 내에 배치할 수 있는 서브 컬렉션 처럼 다른 GUI 씬에 추가할 수 있는 복합적인 노드로 구성된 GUI 씬입니다. 서브 컬렉션은 서브 컬렉션 루트(root)의 위치와 스크립트에 정의된 프로퍼티만 오버라이드(override)할 수 있지만, GUI 템플릿 노드는 모든 프로퍼티 값들을 오버라이드(override)할 수 있습니다. 또한 서브 컬렉션 처럼, GUI 템플릿 노드는 런타임 개념으로 존재하지 않으며 에디터 도구에서만 존재 합니다.
+
+## Creating and using a template
+GUI 템플릿은 일반적인 GUI 씬이므로, 템플릿을 만드는 방법은 특별한 차이가 없습니다. 우리가 버튼 템플릿 하나를 만들어 사용한다고 가정해 봅시다. 우리는 GUI 씬에 기본 버튼 하나를 만들어 파일로 저장할 수 있습니다.
+
+![Button template](images/gui-templates/gui-templates-button.png)
+
+이제 다른 GUI 씬에 이 버튼의 인스턴스 여러 개를 추가할 수 있습니다. 새 씬을 열거나 생성해서 **Gui ▸ Add Template Node**를 선택하고, 아니면 **Outline** 창에서  **Nodes** 폴더에 마우스 오른쪽 버튼을 눌러 드롭 다운 메뉴에서 **Add Template**를 선택합니다.
+
+![Add template](images/gui-templates/gui-templates-add-template.png)
+
+템플릿으로 사용할 GUI 씬 파일(이 예제에서는 "button.gui")을 선택합니다. 동일한 템플릿으로 기반한 인스턴스를 여러 개 추가할 수 있습니다. 만약 템플릿을 수정하면, 각 인스턴스도 에디터상에서 즉시 업데이트 되어 변경사항이 반영됩니다. 템플릿 노드에 표시되는 모든 노드들은 **Outline** 창에서 액세스 할 수 있습니다. 템플릿 밑에 있는 노드들은 "[템플릿 노드 id]/"를 접두어로 사용해 자동으로 이름이 정해집니다.
+
+![Node instances](images/gui-templates/gui-templates-instances.png)
+
+### Overloading properties
+각 인스턴스 노드는 템플릿에 설정된 모든 프로퍼티를 오버로드(overload) 할 수 있습니다. 그냥 편집하려는 노드를 선택하고 변경하려는 프로퍼티를 수정하기만 하면 됩니다. 오버로드된 프로퍼티를 가진 노드들은 **Outline** 창에서 녹색으로 표시되며 오버로드된 프로퍼티는 파란색으로 표시됩니다. 파란색 프로퍼티 이름을 클릭해서 프로퍼티의 값을 기본값으로 리셋할 수 있습니다.
+
+![Overloaded properties](images/gui-templates/gui-templates-overloaded.png)
+
+## Layers
+레이어는 그냥 우리가 예상한대로 동작합니다. 템플릿 파일의 특정 레이아웃으로 셋팅된 프로퍼티는 해당 레이어가 존재하는 경우에 인스턴스 노드의 레이아웃에 반영됩니다. 반대로, 템플릿 노드 인스턴스에 오버로드(overloads)하면 현재 선택된 레이아웃에 영향을 줍니다.
+
+![Overloading in layers](images/gui-templates/gui-templates-layers.png)
+
+## Scripting
+템플릿 노드 메커니즘을 통해 Lua 스크립트로 추가된 노드들을 다루거나 쿼리할 수 있습니다. 노드들은 접두어 기반 템플릿 노드를 포함한 전체 이름으로 지정해야 합니다.
+
+```lua
+if gui.pick_node(gui.get_node("button_ok/frame"), x, y) then
+    -- Do something...
+end
+```
+
+런타임시에는 템플릿 노드를 표현할 수 없습니다. 템플릿 노드의 모든 노드들은 게임에 추가되지만 템플릿 노드는 에디터상에서만 존재합니다. 또한 스크립트를 템플릿 GUI 씬에 추가하면, 이 스크립트는 무시됩니다. 오직 한 개의 스크립트만 각 GUI씬과 엮을 수 있으며 일반적으로 **Outline** 창의 씬 루트 노드(scene root node)만 설정할 수 있습니다.
+
+

docs/ko/manuals/gui-text.md

@@ -0,0 +1,48 @@
+# GUI text nodes
+Font는 GUI 씬에서 text 노드를 렌더링하는데 사용됩니다. 이 매뉴얼은 GUI 씬에서 텍스트를 다루는 방법에 대해 설명합니다.
+
+## Adding text nodes
+GUI text 노드에서 사용할 폰트는 GUI 컴포넌트에 추가해야 합니다. **Fonts** 폴더에서 마우스 오른쪽 버튼을 누르거나 상단 메뉴의 **GUI** 메뉴에서 단축키를 눌러 폰트를 추가합니다.
+
+![Fonts](images/gui-text/fonts.png)
+
+Text 노드는 몇 가지 특별한 프로퍼티를 가지고 있습니다.
+
+#### Font
+생성한 모든 text 노드는 Font 프로퍼티를 설정해야 함
+#### Text
+이 속성에 포함된 문자를 표시함
+#### Line Break
+pivot 설정에 따라 텍스트를 정렬하고 텍스트를 여러 줄로 나눌지를 결정함. 노드의 넓이에 따라 줄바꿈(wrap)이 결정됨.
+
+## Alignment
+노드의 pivot 를 설정해서 텍스트의 adjust mode를 변경할 수 있습니다.
+
+#### Center
+pivot이 "Center", "North", "South" 이면 텍스트가 중앙 정렬됩니다.
+#### Left
+pivot이 "West" 이면 텍스트가 왼쪽 정렬됩니다.
+#### Right
+pivot이 "East" 이면 텍스트가 오른쪽 정렬됩니다.
+
+![Text alignment](images/gui-text/align.png)
+
+## Modifying text nodes in runtime
+Text 노드는 크기, 피벗, 색상 등을 설정하는 일반적인 함수에도 반응하지만 텍스트 노드 전용의 몇몇 함수도 존재합니다.
+
+* text 노드의 폰트를 변경하기 위해 gui.set_font() 함수 호출
+* text 노드의 줄바꿈(line break)를 변경하기 위해 gui.set_line_break() 함수 호출
+* text 노드의 내용을 변경하기 위해  gui.set_text() 함수 호출
+
+```lua
+function on_message(self, message_id, message, sender)
+    if message_id == hash("set_score") then
+        local s = gui.get_node("score")
+        gui.set_text(s, message.score)
+    end
+end
+```
+
+![Set text](images/gui-text/score_gui.png)
+
+![Set text](images/gui-text/score.png)

docs/ko/manuals/gui.md

@@ -0,0 +1,394 @@
+# GUI
+Defold는 유저 인터페이스의 구성과 구현을 위해 맞춤형 커스텀 GUI 에디터와 강력한 스크립팅 기능을 제공합니다. 이 매뉴얼은 이러한 기능을 설명합니다.
+
+Defold의 그래픽 유저 인터페이스(graphical user interface)는 컬렉션에 배치된 게임 오브젝트에 첨부하는 게임 오브젝트 컴포넌트입니다. 이 컴포넌트는 아래의 프로퍼티들을 가집니다.
+
+* 유저 인터페이스의 해상도(resolution)와 종횡비(aspect ratio)를 독립적으로 렌더링하는 간단하지만 강력한 레이아웃 기능
+* gui 스크립트를 통하여 논리 동작(logic behavior)을 연결할 수 있음
+* 게임의 플레이 화면과는 별도로 컨텐츠 위쪽(on top)에서 렌더링됨
+* 카메라 뷰가 독립적인 화면 공간의 좌표 시스템(screen-space coordinate system)에 맞춰 렌더링되며, 카메라를 움직이더라도 GUI 요소는 화면에 그대로 유지됨
+
+GUI는 컬렉션의 좌표계에 속하지 않고, 게임 뷰와는 독립적으로 렌더링 됩니다. 그렇기 때문에 GUI를 컬렉션 에디터에서 특정 위치에 배치할 수 없으며 시각적 표현(visual representation)을 가지지도 않습니다. 하지만 GUI 컴포넌트는 컬렉션에 위치한 게임오브젝트에 상주해야 합니다. 게임 오브젝트의 위치를 바꿔도 GUI에는 영향을 미치지 않습니다.
+
+> 렌더링 동작은 렌더 스크립트에서 변경할 수 있지만 일반적으로 화면의 특정 지점에 HUD 항목과 메뉴가 필요하기 때문에 유저 인터페이스는 게임 뷰의 상위(top)에 별도의 시각적 표현인 "레이어(layer)"를 사용하여 정렬(arrangement)하는 것이 바람직 합니다.
+
+## Nodes
+GUI 컴포넌트는 여러 개의 노드로 구성됩니다. 노드는 아래 항목에 해당하는 시각적 오브젝트입니다.
+
+* Box node, 사각형에 색상이나 텍스쳐로 채워짐
+* Text node, 자세한 것은 [Text nodes](Text%20nodes) 문서 참고
+* Pie node, 자세한 것은 [Pie nodes](Pie%20nodes) 문서 참고
+* Template node, 자세한 것은 [Template nodes](Template%20nodes) 문서 참고
+* Spine node, 자세한 것은 [Spine nodes](Spine%20nodes) 문서 참고
+
+노드는 단순하고 어떠한 로직도 포함하고 있지 않습니다. 에디터상에서나 런타임시 스크립트를 통하여 이동(translate or move)하거나 부-모 관계를 정렬(order)시킬 수는 있습니다. 스크립트 코드로 GUI 컴포넌트의 모든 노드들에게 직접적으로 액세스 할 수 있습니다. 노드는 스크립트로 애니메이션 시킬 수 있고(아래 [Property animation](Property%20animation) 참고) 애니메이션은 노드에서 실행될 수 있습니다(Box node의 플립북(flipbook) 애니메이션 그리고 Spine node의 본(bone) 애니메이션).
+
+"Nodes" 폴더에서 마우스 오른쪽 버튼을 눌러 "Add Box", "Add Text", "Add Pie", "Add Template", "Add Spine Node" 중 하나를 선택해 노드를 추가합니다.
+
+![Add nodes](images/gui/gui_add_nodes.png)
+
+상단의 GUI 메뉴를 사용하거나 키보드 단축키 "I" 와 "O"를 사용하여 box나 text 노드를 추가할 수 있습니다. 배치된 노드는 게임 오브젝트를 움직이는 것과 같은 방법으로 컬렉션 에디터상에서 이동하고 회전시킬 수 있습니다.
+
+### Node properties
+각 노드에는 이들의 외형(appearance)을 제어하는 많은 프로퍼티가 있습니다.
+
+* Position, Rotation, Scale, Size (애니메이션 적용 가능)
+* Color, Outline, Shadow (애니메이션 적용 가능)
+* Blend mode
+* Adjust mode, Pivot, Xanchor, Yanchor
+* Font, Text, Line-break (text node 전용)
+* Index, Layer, Parent
+* Clipping (box node와 pie node 전용) (자세한 것은 [Clipping](gui-clipping) 참고)
+
+이들 프로퍼티는 에디터의 프로퍼티 탭에서 수정(인덱스(index) 설정과 부모관계(parenting) 설정은 안됨)하거나 스크립트를 통해 수정([GUI API](http://www.defold.com/ref/gui) 참고)하는 것이 가능합니다.
+
+이들 각 프로퍼티는 스크립트를 통해 애니메이션을 적용할 수도 있습니다. (아래 [Property animation](Property%20animation) 참고) 
+
+## Textures and flip book animations
+GUI 인터페이스 컴포넌트의 일부분으로 텍스쳐 아틀라스나 타일 소스의 이미지나 애니메이션을 사용 할 수 있습니다. 먼저 이미지 리소스(아틀라스 혹은 타일 소스)가 추가하면 이 리소스에 포함된 모든 이미지와 애니메이션을 GUI 노드에 반영할 수 있습니다. 상단의 "GUI" 메뉴를 사용하거나 키보드 단축키를 사용하거나 "Textures" 폴더에 마우스 오른쪽 버튼을 눌러서 텍스쳐를 추가해 보세요.
+
+GUI에 추가된 텍스쳐는 box나 pie 노드에 반영할 수 있습니다.
+
+![Textures](images/gui/gui_texture.png)
+
+선택된 텍스쳐 애니메이션(혹은 싱글 프레임 이미지)은 GUI 컴포넌트가 화면에 그려지면 자동적으로 재생됩니다.
+
+box 노드의 색은 애니메이션의 색조를 조정(tint)합니다. 색조(tint color)는 이미지 데이터에 곱해지게 되는데, 즉 흰색(기본값)으로 설정하면 색조가 적용되지 않습니다.
+
+![Tinted texture](images/gui/gui_tinted_texture.png)
+
+> Box 노드는 텍스쳐가 할당되지 않았거나 알파값이 0이거나 사이즈가 0,0,0이어도 항상 렌더링 됩니다. Box 노드는 텍스쳐를 항상 할당해 두는 것이 좋습니다. 만약 빈(empty) 노드가 필요하다면 텍스쳐를 할당해 둔 채 사이즈를 0,0,0 으로 설정하십시오.
+
+## Slice-9 texturing
+많은 GUI와 HUD는 크기와 관련한 민감한 문제가 있습니다. 패널과 다이얼로그는 포함된 컨텐츠의 크기에 맞게 리사이즈할 필요가 종종 있는데, 텍스쳐를 스케일된 노드에 반영할 경우 문제가 발생합니다. 예를 들어, 버튼에 작성할 텍스트의 길이 만큼 넓이가 고정된 큰 버튼을 사용하려 한다고 칩시다. Box 노드를 만들어 텍스쳐를 반영하고 스케일을 변경하면 아래와 같이 됩니다.
+
+![GUI bad scaling](images/gui/gui_scaling.png)
+
+Defold는 이 같은 문제를 해결하기 위해 slice-9 texturing 이라는 기능을 포함하고 있습니다. 이 기능은 노드의 스케일이 변경될 때 노드 텍스쳐 일부분의 사이즈를 유지해 줍니다. 이를 노드에 반영하면 버튼 텍스쳐는 조각나게 되고 버튼 노드의 가로 사이즈를 변경해도 양 끝의 부분은 스케일 되지 않습니다.
+
+![Sliced scaling](images/gui/gui_slice9_scaling.png)
+
+따라서 이 간단한 테크닉을 사용하면 어떠한 넓이의 버튼도 예쁘게 만들 수 있습니다. box 노드의 **Slice9** 프로퍼티는 텍스쳐를 어떻게 잘라낼(slice) 것인지를 제어합니다.
+
+![Slice 9 properties](images/gui/gui_slice9_properties.png)
+
+**Slice9**는 노드가 리사이징 될 때 고정할 마진 넓이(margin width)를 지정하는 픽셀단위의 4개 숫자로 제어합니다. 모서리 부분(corner segments)은 스케일 되지 않고 이동만 되며, 가장자리 부분(edge segments)은 하나의 축(axis)을 따라 스케일 되고, 중앙 부분(center segment)은 가로세로 둘 다 스케일 됩니다. 이 마진값은 왼쪽 부터 시계 방향으로 설정 됩니다.
+
+![Slice 9 property sections](images/gui/gui_slice9_sections.png)
+
+렌더러에서 밉맵(mipmap)이 작동하는 방식 때문에, 텍스쳐 세그먼트(texture segments)의 스케일링은 때로 이상하게 보일 수도 있습니다. 이는 원래의 텍스쳐 사이즈보다 작게 세그먼트의 스케일을 줄이는 경우 발생하므로 렌더러는 세그먼트를 위한 낮은 해상도의 밉맵을 선택하여 이상현상을 해결합니다.
+
+![Slice 9 mipmapping](images/gui/gui_slice9_mipmap.png)
+
+이 문제를 피하는 것은 쉽습니다. 원본 텍스쳐(source texture)에서 스케일 할 영역(segment)을 더 이상 스케일 다운이 불가능하고 오로지 스케일 업만 가능하게끔 충분히 작게 만들면 됩니다.
+
+> 텍스쳐 메모리를 절약하기 위해서는 상단이나 하단 가장자리 영역(edge segment)을 1픽셀로 만드는 것이 바람직합니다. 하지만 이럴 경우 텍스쳐 필터링으로 인해 원치 않는 현상이 나타날 수도 있습니다. 가장자리(edge)를 좀 더 늘리면 인접한 픽셀값(neighbor pixels)으로 시작하고 중단하게 되므로 일반적으로 더 나은 결과를 얻게 됩니다.
+
+## Index: rendering order
+모든 노드들은 "Nodes" 폴더에 나열된 순서에 따라 렌더링됩니다. 목록의 맨위에 있는 노드가 첫 번째로 그려지므로 다른 노드의 뒷쪽(behind)에 나타납니다. 목록의 맨 아래에 있는 노드는 맨 마지막에 그려지므로 모든 노드들의 맨 앞(front)에 나타납니다. 목록에 있는 노드를 드래그해서 이들의 인덱스 순서를 변경할 수 있습니다.
+
+또한 레이어를 사용해서 노드 순서를 그룹화 하고 변경할 수도 있습니다. (아래 참고)
+
+만약 node의 Z 값을 설정해도 그리기 순서(draw order)는 바뀌지 않습니다. 노드에서 Z 값은 무시됩니다.
+
+### Parent-child hierarchies
+노드를 다른 노드로 드래그해서 부모-자식 관계를 만들 수 있습니다. 부모가 있는 노드는 부모에 반영되고 부모 피벗(parent pivot: 아래 참고)에 상대적인 트랜스폼(transform: 위치, 회전, 스케일 변경)을 상속합니다. 자식 노드들은 부모 이후에 그려지므로 부모 노드의 앞쪽에 나타나게 됩니다. 레이어를 사용하면 부모와 자식노드의 그리기 순서를 변경하고 노드의 렌더링을 최적화 할 수 있습니다. (아래 "Batch Rendering" 참고)
+
+## Layers
+레이어(layer)를 사용하면 노드를 그리는 방법을 좀 더 세밀하게 제어할 수 있습니다. 레이어를 노드에 반영하면 레이어의 일부로서 그려지게 됩니다. 레이어 그리기 순서는 일반적인 노드의 순서보다 우선하게 됩니다.
+
+![Layers](images/gui/gui_layers.png)
+
+이 예제에서 "box2" 오렌지색 box 노드는 "front" 레이어의 일부이며 레이어 순서에 따라서 맨 마지막에 그려지게 됩니다. 즉 "front" 레이어의 모든 노드는 레이어에 속하지 않은 노드들과 "back" 레이어의 노드들을 뒤로 한 채 최상위에 그려지게 됩니다.
+
+"box1"과 "box3" 둘 다 "back" 레이어로 셋팅되어 있을 경우, 이 레이어 안에서의 그리기 순서는 노드 리스트에 배치된 노드의 인덱스에 의해서 결정됩니다. "box1"이 "box3" 위에 있으므로 "box3"의 뒷쪽으로 먼저 그려지게 됩니다.
+
+> 설정되지 않은 레이어를 사용한 자식 노드는 부모 노드의 레이어 설정을 암시적으로 상속합니다. 노드에 레이어를 설정하지 않으면 암시적으로 "null" 레이어를 추가해서 다른 레이어들 보다 먼저 그려지게 됩니다.
+
+## Batch rendering
+GUI를 가능한 효율적으로 렌더링 하기 위해서, 엔진이 GUI 노드들을 일괄적으로 모아서 그리는, 즉 엔진이 만드는 드로우콜(drawcalls)의 수를 줄이는 단계가 있습니다. 만약 노드들의 그룹이 아래의 조건을 충족하면 단일 배치(single batch) 내에서 처리될 수  있습니다.
+
+1. 모두 box 노드 뿐이라면, 텍스쳐를 같은 아틀라스에서 사용 해야함
+2. 노드들은 같은 블렌드 모드(blend mode)로 렌더링 해야 함
+3. text 노드가 여러 개 라면, 동일한 폰트를 사용해야함
+4. 순서대로 렌더링 되어야 함. 즉 노드 리스트에서 하위 계층에 함께 포함되거나 같은 레이어에 속해야 함 (자세한것은 아래 예제 참고)
+5. 게다가, clipping 노드는 항상 일괄처리(batch)를 중단하고 각 스텐실 범위(stencil scope) 또한 일괄처리(batch)를 중단함.
+
+계층구조(hierarchies)에서 노드들을 정렬 하는 기능은 강력하며, 노드의 복잡한 계층을 관리 가능한 단위로 그룹화 하기 쉽습니다. 하지만 계층구조(hierarchies)는 효과적으로 배치 렌더링(batch rendering)을 중단할 수도 있습니다. 아래 간단한 예제를 봅시다.
+
+![Batch hierarchy](images/gui/gui_batch_hierarchy.png)
+
+여기서는 노드 3개씩 2개의 버튼이 있으며 그림자용 텍스쳐가 있는 box 노드와 음영(shaded) 버튼 텍스쳐를 사용한 box노드, 버튼의 텍스트를 사용한 text 노드로 되어 있습니다. 우리는 이들 노드를 논리적으로 관리 가능한 계층에 넣었습니다. 버튼 그래픽은 "alpha" 블렌드 모드로 그려지고, 그림자는 "mutliply" 블렌드 모드로 그려집니다.
+
+렌더링 파이프라인이 노드의 목록을 통과할 때, 각 개별 노드를 위해 개별적인 배치(batch)를 설정해야합니다. 왜냐하면 동일한 아틀라스를 공유하는 노드들이 이 목록을 통과하기 때문입니다. 하지만 그림자 노드는 버튼과 다른 혼합 모드(blend mode)를 사용하기 때문에, 배치(batch)는 각 노드에서 끊어지게 됩니다. 따라서 이들 두 버튼에게는 모두 6개의 개별 배치(batch)가 필요합니다.
+
+하지만 이걸 더 개선할 수도 있습니다. 신중하게 우리의 노드에 레어이를 할당해서 우리의 버튼을 더욱 효율적으로 렌더링 할 수 있습니다. 이 예제에서는 3개의 레이어를 만들도록 합니다.
+
+1. Shadow
+2. Button
+3. Text
+
+노드를 해당 레이어에 할당하고 Layers 목록에서 레이어가 올바른 렌더링 순서로 배치되어 있는지 확인합니다.
+
+![Batch layers](images/gui/gui_batch_layers.png)
+
+레이어 그리기 순서가 일반적인 노드 순서보다 우선하므로 노드들은 아래 순서대로 그려지게 됩니다.
+
+1. play_block_shadow
+2. quit_block_shadow
+3. play_block
+4. quit_block
+5. play
+6. quit
+
+아틀라스 노드, 블렌드 모드, 폰트를 공유하는 노드는 서로 인접해 있으며 렌더링 파이프라인은 이들 노드를 6개 대신 3개의 배치(batch)로 일괄처리할 수 있습니다. 이는 약 50%의 성능 향상이 있게 됩니다.
+
+이제, 예제의 스케일을 더 넓혀서 GUI를 10개의 버튼으로 만든다고 상상해 봅시다. 우리가 적절한 레이어를 각 새로운 노드에 할당한다면, 엔진은 30개의 드로우 콜이 아니라 여전히 3개의 배치(batch) 안에서 렌더링 할 수 있습니다.
+
+## Script
+Lua 스크립트를 사용하면 GUI의 로직을 제어하고 노드에 애니메이션을 적용할 수 있습니다. GUI 스크립트는 일반적인 게임 오브젝트 스크립트와 동일하게 동작하지만 다른 종류의 파일로 저장되고 "gui" 모듈의 함수에 액세스 할 수 있습니다.
+
+프로젝트에서 GUI 스크립트 파일을 생성하고 Outline 창에서 최상위(root) GUI 컴포넌트를 선택해서 Properties 창에서 Script 항목에 생성한 GUI 스크립트 파일을 지정합니다.
+
+![Script](images/gui/gui_script.png)
+
+이 스크립트 파일은 기본적으로 게임 오브젝트 스크립트와 같은 함수를 가지고 있습니다.
+
+```lua
+function init(self)
+end
+
+function final(self)
+end
+
+function update(self, dt)
+end
+
+function on_message(self, message_id, message, sender)
+end
+
+function on_input(self, action_id, action)
+end
+
+function on_reload(self)
+end
+```
+
+GUI 컴포넌트는 게임 오브젝트 처럼 입력(input)과 메세지(message)를 받을 수 있습니다. URL의 fragment 부분의 컴포넌트를 지정하여 GUI컴포넌트에 메세지를 보낼 수 있습니다.
+
+```lua
+local msgdata = { score = 4711, stars = 3, health = 6 }
+msg.post("hud#gui", "set_stats", msgdata)
+```
+
+## Handling different resolutions and aspect ratios
+GUI 컴포넌트는 게임 컨텐츠의 앞(top)에서 별도로 렌더링 되며, 게임 개발자들이 해상도(resolutions)와 종횡비(aspect ratios)가 다른 화면의 장치를 쉽게 다루기 위한 몇 가지 메커니즘이 있습니다.
+
+Defold 게임 프로젝트는 "game project" 셋팅에서 목표 해상도(target resolution)를 지정할 수 있습니다. 하지만 여러 장치의 해상도와 종횡비 화면을 지원해야 한다면, 목표 화면에 맞추기 위해 업스케일(upscale)이나 다운스케일(downscale)이 필요할 수도 있습니다.
+
+Defold는 GUI 컴포넌트를 게임 컨텐츠와 다르게 스케일을 처리합니다. 또한 해상도와 종횡비에 관계 없이 유저 인터페이스를 배치할 수 있는 간단하고 강력한 레이아웃 기능을 제공합니다.
+
+GUI를 사용해 게임 앱을 만들어서 간단한 실험을 해 보도록 합시다. 화면 사이즈를 1024x1024 크기의 정사각형으로 설정하고 배경 이미지 위에 레벨 메뉴를 GUI 컴포넌트로 배치합니다. 컴퓨터에서 이를 실행하면 어떻게 보일까요?
+
+![Square](images/gui/gui_square.png)
+
+이제 이 앱을 iPad에서 실행하면(종횡비가 4:3이고 화면 크기가 다름) 아래와 같이 보이게 됩니다.
+
+![iPad square](images/gui/gui_ipad.png)
+
+우리는 iPad에서 게임이 화면에 채워지도록 늘어난(stretche) 것을 볼 수 있습니다. 배경의 문어 이미지는 변형되었지만 GUI 컴포넌트는 그렇지 않았습니다. text 노드는 올바른 종횡비로 렌더링 되어 화면 중앙의 위치를 유지합니다.
+
+실행중인 Defold 게임의 창 크기를 변경해서 해상도와 종횡비를 바꾸는 것을 쉽게 시뮬레이션 할 수 있습니다. 해상도와 종횡비가 다른 장치에서 게임을 실행하는 것은 윈도우 창을 늘리고 줄이는 것과 동일합니다. 윈도우 창 크기를 변경하면 유저인터페이스 레이아웃을 제어하는 조정(adjustment)과 앵커(anchor) 규칙에 따라 GUI 컴포넌트를 다시 그리거나 재배치하는 동작이 트리거됩니다.
+
+### Adjust mode
+윈도우 사이즈가 변경되어 해상도와 종횡비도 변경되면, 모든 노드들은 Adjust Mode 프로퍼티 설정에 따라 모양이 변경(resharped) 되고 조정(adjusted) 됩니다. 이 프로퍼티는 아래 3개의 셋팅이 있습니다.
+
+1. Fit(맞춤). 기본값. 이 노드는 바운딩 박스의 넓이나 높이 중 작은 크기에 비례하여 균일한 비율로 리사이징함.
+2. Zoom(줌). 이 노드는 바운딩 박스의 넓이나 높이 중 큰 크기에 비례하여 균일한 비율로 리사이징함.
+3. Stretch(늘이기). 이 노드는 화면 크기에 비례하여 모양이 바뀜.
+
+몇 개의 노드를 사용해 GUI 컴포넌트를 포함한 아래 예제를 살펴보면 adjust mode에 대해 쉽게 이해할 수 있습니다.
+
+* 참고용으로 배경에 모눈 텍스쳐(grid texture)를 가진 box 노드를 배치하고 **Adjust Mode**를 "Stretch"로 셋팅함
+* Defold 로고 텍스쳐를 사용한 256x256 픽셀 box 노드 세 개를 배치하고 **Adjust Mode**를 각각 "Fit", "Zoom", "Stretch"로 셋팅함
+
+![Adjust mode](images/gui/gui_adjust.png)
+
+이제 윈도우 사이즈가 변경될 때 box 노드들이 어떻게 바뀌는지 봅시다.
+
+![Resized window](images/gui/gui_adjust_resize.png)
+
+"Stretch"  노드는 새로운 모양에 따라 변경되지만 "Fit"과 "Zoom" 노드는 종횡비를 유지합니다. "Fit" 노드는 모양이 변형된 바운딩 박스(모눈 사각형 안에서)의 안쪽에서 비율을 유지하고 "Zoom" 노드는 모양이 변경된 바운딩 박스를 덮어버리며 비율을 유지합니다.
+
+Text 노드도 똑같은 방식으로 동작합니다. adjust mode는 텍스트의 모양을 제어하는 숨겨진 바운딩 박스에 반영됩니다.
+
+## Anchors
+앵커는 창 크기가 변경될 때 노드의 위치를 바운딩 박스 내에서 제어합니다. 새 노드는 앵커가 없는 상태로 만들어지므로 화면의 중앙을 기준으로 배치됩니다.
+
+### Node repositioning without anchors
+생성된 노드의 기본 동작은 다음과 같습니다.
+
+* GUI 컴포넌트의 좌표계는 창 사이즈의 중앙을 기준으로 균등하게 스케일 됨.
+* 노드는 스케일된 좌표계에서 위치를 유지함
+
+즉 앵커가 없는 노드들은 화면의 중앙을 기준으로 상대거리를 유지합니다. 예를 들어, 윈도우가 좌우로 늘어난다면, 추가 넓이는 GUI의 양 측면에 균등하게 분배됩니다.
+
+![No anchor size up](images/gui/gui_no_anchor_sizeup.png)
+
+또한, 윈도우가 축소(shrunk)되어 상대적으로 좁아진다면, 추가 높이는 GUI의 위 아래로 균등하게 분배됩니다.
+
+![No anchor size down](images/gui/gui_no_anchor_sizedown.png)
+
+### Node repositioning with anchors
+Xanchor와 Yanchor 프로퍼티를 셋팅하면 바운딩 박스의 가장 자리를 기준으로 노드의 위치를 잠금(lock) 할 수 있습니다.
+
+* Xanchor를 "Left"로 설정하면 노드의 수평 위치가 box의 왼쪽 가장자리로 고정됩니다.
+* Xanchor를 "Right"로 설정하면 노드의 수평 위치가 box의 오른쪽 가장자리로 고정됩니다.
+* Yanchor를 "Top"으로 설정하면 노드의 수직 위치가 box의 윗쪽 가장자리로 고정됩니다.
+* Yanchor를 "Bottom"으로 설정하면 노드의 수직 위치가 box의 아래쪽 가장자리로 고정됩니다.
+
+실제로 Xanchor 프로퍼티를 "Right"로 설정하고 Yanchor 프로퍼티를 "Top"으로 설정하면, 노드는 box의 오른쪽 위 모서리를 기준으로 위치를 유지하며 오른쪽 가장자리와 상단 가장자리까지와의 거리도 유지됩니다. **"Pivot"** 은 기본값 "Center"로 중심점을 유지하며, 모서리로 앵커를 지정하려면 **Pivot** 값을 적절히 조정하면 됩니다.
+
+![Anchor top right](images/gui/gui_anchor_topright.png)
+
+이 예제는 "Top"과 "Right"로 앵커가 지정된 노드를 보여줍니다. "Fit"이 조정되고 **Pivot**을 "North East"로 설정하면 윈도우 창이 늘어날 때 노드는 변형될 박스(파란색 점선 사각형) 내에서 앵커가 지정되어 맞춰지게 됩니다.
+
+### Pivot
+각 노드는 GUI 좌표계 내에서 위치(position), 스케일(scale), 회전(rotation) 속성을 가지고 있습니다. 노드는 position 속성으로 배치되며 pivot에 설정된 좌표를 기준으로 회전합니다. text노드는 pivot 설정에 따라 정렬됩니다.
+
+노드의 기본 위치와 회전은 **Pivot** 프로퍼티가 "Center"로 설정되어 노드의 중앙을 기준으로 발생합니다. 노드의 pivot은 아래 설정 중 하나로 변경할 수 있습니다.
+
+* Center
+* North, South, East, West
+* North West, North East, South West, South East
+
+다음 그림은 각 pivot 설정의 위치를 보여줍니다.
+
+![Pivot points](images/gui/pivot_points.png)
+
+노드의 pivot을 변경하면 노드는 새 pivot에 주어진 위치로 이동하게 됩니다. Text 노드는 "Center"일 경우 중앙 정렬되며 "West"일 경우 왼쪽 정렬, "East"일 경우 오른쪽으로 정렬됩니다.
+
+## GUI scripts
+GUI노드에는 로직 자체는 없지만 GUI 컴포넌트에 연결된 GUI 스크립트에서 노드를 직접 제어할 수 있습니다. 이 작업은 노드의 id를 사용해 참조하고 이 참조는 일반적으로 변수에 저장되어 노드를 다루는데 사용됩니다.
+
+```lua
+-- "magic" text 노드를 참조함
+local magicnode = gui.get_node("magic")
+-- 노드를 오렌지색으로 바꿈
+local orange = vmath.vector4(1.0, 0.3, 0.0, 1.0)
+gui.set_color(magicnode, orange)
+```
+
+gui.get_node() 함수를 사용해서 노드의 참조를 획득하고 GUI 모듈의 위치, 크기, 모양, 그리기 순서, 부모 관계 변경 등의 다양한 함수를 다룰 수 있습니다. 모든 노드의 프로퍼티들은 스크립트를 통해 접근 가능합니다.
+
+### Node id:s
+각 노드는 유니크한 id를 가지고 있습니다. box 노드를 생성하면 기본 id로 "box"가 설정되며, text 노드는 "text"를 기본 id로 설정되지만 유니크한 이름과 더 명확한 설명을 위해 노드의 id를 변경하는 것이 좋습니다. 만약 Defold의 GUI 에디터에서 중복 id를 감지하면 에러가 발생합니다.
+
+### Dynamically created nodes
+런타임시 스크립트에서 새 노드를 생성하려면 두 가지 방법이 있습니다.
+
+```lua
+-- 300x300 위치에 150x200 사이즈로 흰색 box 노드 생성하기
+local new_position = vmath.vector3(300, 300, 0)
+local new_size = vmath.vector3(150, 200, 0)
+local new_boxnode = gui.new_box_node(new_position, new_size)
+-- 동일한 위치에 text 노드 추가하기
+local new_textnode = gui.new_text_node(new_position, "Hello!")
+```
+
+생성된 노드를 참조하는 변수를 사용하여 노드를 자유롭게 다룰 수 있습니다.
+
+```lua
+-- text노드를 10도 회전하기(z축 기준)
+gui.set_rotation(new_textnode, vmath.vector3(0, 0, 10))
+```
+
+이 코드를 GUI 스크립트의 init() 함수에 넣어 실행하면 아래와 같이 됩니다.
+
+![Script create node](images/gui/gui_script_create_nodes.png)
+
+또 다른 방법으로는 이미 존재하는 노드를 복제하여 새 노드를 생성할 수도 있습니다.
+
+```lua
+-- magic text 노드 복제하기
+local magicnode = gui.get_node("magic")
+local magic2 = gui.clone(magicnode)
+-- 새 노드를 원본 위치의 오른쪽 상단으로 옮기기
+gui.set_position(magic2, vmath.vector3(300, 300, 0))
+```
+
+### Dynamic node IDs
+동적으로 노드를 생성하면 id가 할당되지 않습니다. 이것은 의도적으로 설계되었습니다. gui.new_box_node(), gui.new_text_node(), gui.new_pie_node(), gui.clone() 함수가 반환하는 레퍼런스는 노드에 액세스 하기위한 유일한 값이므로 참조를 추적하기 위해서는 이 값을 꼭 유지해야 합니다.
+
+```lua
+-- text 노드 추가
+local new_textnode = gui.new_text_node(vmath.vector3(100, 100, 0), "Hello!")
+-- "new_textnode"는 노드의 레퍼런스를 포함하고 있음
+-- 이 노드는 id가 없지만 이미 레퍼런스를 가지고 있으므로 gui.get_node()로 호출할 필요가 없음
+```
+
+## Property animation
+노드 프로퍼티의 몇몇은 비동기적으로 애니메이션을 처리할 수 있습니다. 프로퍼티를 애니메이션 처리하려면 gui.animate() 함수를 사용하여 아래 파라미터를 보내면 됩니다.
+
+```lua
+gui.animate(node, property, to, easing, duration [,delay] [,complete_function] [,playback])
+```
+
+> 이 파라미터에 대한 자세한 설명은 [go.animate()](http://www.defold.com/ref/go/#go.animate) 참고
+
+"property" 파라미터는 일반적으로 상수값(gui.PROP_POSITION 등등)이 주어지지만 프로퍼티 가이드의 설정([Properties](Properties) 참고)도 지원합니다. 복합적인 프로퍼티 값의 특정한 컴포넌트를 애니메이션 하려면 이 방법이 편리합니다.
+
+예를 들어, "color" 프로퍼티는 vector4 값으로 red, green, blue, alpha의 RGBA 값을 나타내는데, 벡터 컴포넌트는 "x", "y", "z" 그리고 "w"로 이름이 정해져 있으며 RGBA 순서대로 "w"는 alpha 값에 반영됩니다.
+
+노드의 알파값을 페이드업/다운(fade up/down) 하려면 아래 코드를 사용하여 처리할 수 있습니다.
+
+```lua
+function fadeup(self, node)
+        gui.animate(node, "color.w", 1.0, gui.EASING_LINEAR,
+0.3, 0, fadedown, gui.PLAYBACK_ONCE_FORWARD)
+end
+
+function fadedown(self, node)
+        gui.animate(node, "color.w", 0.0, gui.EASING_LINEAR,
+0.3, 0, fadeup, gui.PLAYBACK_ONCE_FORWARD)
+end
+```
+
+이제 fadeup() 이나 fadedown() 을 호출하여 노드의 알파값을 애니메이션 처리할 수 있습니다. "complete_function" 프로퍼티를 사용하면 애니메이션을 완료될 때 호출되게 해서 페이드 업과 페이드 다운을 끊임없이 지속되게 할 수 있습니다.
+
+## Render script
+기본 렌더 스크립트는 게임 컨텐츠의 모든 렌더링을 다루는 루아 스크립트로 되어 있으며(자세한 내용은 [Rendering](Rendering) 문서 참고), 게임의 상위에서 GUI 노드들을 렌더링 하도록 별도 방법으로 설정됩니다.
+
+```lua
+...
+render.set_view(vmath.matrix4())
+render.set_projection(vmath.matrix4_orthographic(0,
+render.get_window_width(), 0,
+render.get_window_height(), -1, 1))
+render.draw(self.gui_pred)
+render.draw(self.text_pred)
+...
+```
+
+이 뷰는 [일반 단위 행렬(normal identity matrix)](https://ko.wikipedia.org/wiki/단위행렬)이며 직교(orthographic)로 투영(projection)됩니다. "builtins/render" 폴더에서 "default.render_script" 와 "default.render" 파일을 복사하고 project settings([Project settings](Project%20settings) 참고)에서 "bootstrap" 섹션의 렌더러를 수정하여 렌더 스크립트를 커스터마이징 할 수 있습니다.
+
+예를 들어, 모든 GUI 컴포넌트를 3D "camera" 뷰와 원근 투영(perspective projection)을 사용하여 렌더링 할 수 있습니다.
+
+```lua
+-- 뷰를 3D 포지션 카메라로 설정하기
+local w = render.get_window_width() * 0.5
+local h = render.get_window_height() * 0.5
+local view = vmath.matrix4_look_at(vmath.vector3(w-25, h-10, 70),
+vmath.vector3(w, h, -250),
+vmath.vector3(0, 1.0, 0))
+render.set_view(view)
+-- 원근 투영시키기(Perspective projection)
+render.set_projection(vmath.matrix4_perspective(2.5, 4/3, 0.1, 1000))
+
+render.draw(self.gui_pred)
+render.draw(self.text_pred)
+```
+
+이것은 렌더링되는 모든 GUI 컴포넌트들에게 영향을 줍니다. 위에서 만든 레벨 메뉴에 수정된 렌더 스크립트를 적용하면 아래 처럼 나타납니다.
+
+![Render script](images/gui/gui_renderscript.png)

docs/ko/manuals/html5.md

@@ -0,0 +1,215 @@
+# HTML5 게임 개발하기
+이 매뉴얼은 HTML5 캔버스 어플리케이션을 개발하는 과정에 대해 설명하고, 알려진 이슈들과 몇 가지 제약사항에 대해 설명합니다.
+
+## Project configuration
+"game.project" 파일에는 HTML5 을 위한 몇 가지 특정 설정값이 있으며  **html5** 섹션에서 찾을 수 있습니다.
+
+![Project settings](images/html5/html5_project_settings.png)
+
+### Customizing heap size
+Defold는 Emscripten(http://en.wikipedia.org/wiki/Emscripten 참고) 를 사용하여 HTML5 을 지원하고 있습니다. 즉 어플리케이션 동작이 힙(heap) 안에서 이루어지는 샌드박스 메모리를 생성한다는 뜻입니다. 기본적으로 엔진은 많은 양의 메모리(256MB)를 할당합니다. 이는 일반적인 게임에는 충분하지만 최적화를 통해서 더 작은 메모리를 사용할 수도 있습니다. 다음 단계를 따라해 보세요.
+
+1. **custom_heap_size** 를 원하는 바이트 값으로 설정합니다. 
+2. **set_custom_heap_size**를 체크해서 활성화 합니다.
+3. HTML5 번들을 생성합니다. (아래 참고)
+
+### Monitoring memory usage
+개발하는 동안에는 특수한 메모리를 추적하는 컴포넌트가 포함된 번들을 생성해서 어플리케이션 메모리 사용량을 추적할 수 있습니다. 이 기능은 **include_dev_tool**를 체크해서 활성화 되며 아래에서 더 자세히 설명합니다.
+
+### Application cache
+네트워크 트래픽을 줄이고 로딩 시간을 개선하기 위해, HTML5 어플리케이션 캐쉬(https://developer.mozilla.org/en-US/docs/Web/HTML/Using_the_application_cache 참고) 내에 어플레케이션 데이터를 저장하도록 선택할 수 있습니다. 일반적으로 이 기능은 개발 중에는 사용되지 않고 브라우저는 새로 생성된 컨텐츠보다는 캐쉬된 데이터를 우선하게 됩니다. 만약 이 기능을 테스트 중에 사용한다면 빌드할 새 번들은 캐쉬 메니페스트(cache manifest)를 변경해야 새 데이터를 가져올 수 있게 됩니다. 모든 브라우저는 캐쉬를 삭제(clear)하는 기능을 제공하고 있습니다.
+
+### Creating HTML5 content
+Defold에서 HTML5 컨텐츠를 생성하는 것은 간단하며 다른 모든 지원되는 플랫폼들 처럼 동일한 패턴으로 따라하기만 하면 됩니다. 메뉴에서 **Project > Bundle > HTML5 Application…​** 를 선택합니다.
+
+![Build HTML5](images/html5/html5_build_launch.png)
+
+어플리케이션을 생성하기위한 폴더를 선택하라는 창이 뜹니다. 익스포트 과정이 완료되면 어플리케이션을 실행하는데 필요한 모든 파일을 볼 수 있습니다.
+
+![Application files](images/html5/html5_files.png)
+
+### Testing HTML5 Content
+이제 이 컨텐츠를 웹서버가 액세스 할 수 있는 디렉토리에 설치해야 합니다. 사용 가능한 테스트 환경은 프로젝트에 따라 달라집니다. 이 환경에서는 그냥 .html 페이지를 열기만 해도 됩니다.
+
+![Application](images/html5/html5_goat.png)
+
+또한 에디터에서 HTML 컨텐츠를 직접 실행해서 로컬 브라우저에서 열 수도 있습니다. 하지만 게임의 기능에 따라 웹 서버에서 어플리케이션을 테스트 하는 것이 더 좋습니다.
+
+### Known issues and limitations
+
+#### Live update
+Defold 어플리케이션은 에디터에서 라이브 업데이트를 받기 위해 자체적인 소형 웹 브라우저를 실행 해야만 합니다. 다른 일반적인 순수 브라우저 어플리케이션으로는 불가능합니다.
+#### CORS
+Cross-origin resource sharing (http://en.wikipedia.org/wiki/Cross-origin_resource_sharing 참고)는 QA환경에서는 활성화 되지 않으므로 브라우저가 웹 API와 상호작용하는 기능이 제한될 수 있습니다. Chrome을 사용할 때, '--disable-web-security' 플래그로 실행하거나 프록시 서버를 만들어서 이 문제를 해결할 수 있습니다.
+#### Safari (IndexedDB)
+영구적인 사용자 데이터(Persistent user data)는 IndexedDB API (https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API 참고)를 사용해서 로컬에 저장됩니다. 이 HTML5의 기능은 현재 Safari 버전에서는 지원되지 않습니다. 따라서 이 브라우저를 사용할 경우엔 세션(sessions) 간에 데이터가 저장되지 않습니다. 이 기능은 다음 업데이트에 포함될 예정입니다.
+#### Internet Explorer 11 (audio)
+Defold는 HTML5 WebAudio (http://www.w3.org/TR/webaudio 참고)를 사용하여 오디오 재생을 다루며 Internet Explorer 11 에서는 이 기능이 지원되지 않습니다. 이 브라우저에서 사용하면 에러가 발생할 수 있습니다.
+#### Internet Explorer 11 (WebGL)
+Microsoft는 WebGL API (https://www.khronos.org/registry/webgl/specs/latest/ 참고) 구현을 완료하지 않았습니다. 따라서 다른 브라우저들 처럼 동작하지 않을 수 있습니다.
+#### Internet Explorer 11 (Full screen)
+풀 스크린 모드는 이 브라우저에서 제대로 동작하지 않는 경우가 있습니다.
+
+## Customizing HTML5 applications
+어플리케이션의 HTML5 버전을 생성할 때, Defold는 어플리케이션이 위치할 기본 웹 페이지를 제공하며 어플리케이션을 어떻게 표시할지 도와주는 style(css)과 script 리소스들을 참조합니다.
+
+일반적으로, 어플리케이션을 실행하는데 필요한 모든 리소스를 가져오는데 걸리는 시간은 무시할 수 없습니다. 이런 이유로, Defold HTML5 어플리케이션은 메인 어플리케이션을 로드하는 동안 보여주는 스플래쉬 스크린(splash screen) 기능을 제공합니다.
+
+이를 재정의 하지 않는 한, Defold는 아래 처럼 구성된 기본 페이지를 제공합니다.
+
+\+ HTML5 캔버스 + 풀스크린 모드 버튼 + 스플래쉬 스크린 및 로직 + 필요하다면 개발 도구들
+
+이 컨텐츠는 어플리케이션을 익스포트 할 때마다 새로 생성됩니다. 만약 이 요소들을 커스터마이징 하려면 프로젝트 설정을 수정해야 합니다. Defold 에디터의 **game.project** 를 열어서 **html5** 섹션을 찾아 보세요.
+
+![HTML5 settings](images/html5/html5_styling_settings.png)
+
+이 설정은 커스텀 HTML 파일, 스타일시트(css), 스플래시 이미지를 추가할 수 있게 해 줍니다.
+
+> 이 작업을 시작하려면, 어플리케이션을 기본 설정으로 한 번 익스포트 한 후 익스포트된 HTML과 CSS 파일을 프로젝트로 옮겨서 위의 설명대로 설정을 변경하고 이 파일들을 수정하면 됩니다.
+
+이 컨텐츠는 언제든 자유롭게 변경하거나 추가할 수 있지만, 몇 가지 제약 사항이 있습니다.
+
+\+ 캔버스는 다른 스타일로 border 나 padding 을 지정하면 안됩니다. 이렇게 하면 마우스 입력 좌표가 달라질 수 있습니다. \+ 페이스북 지원이 필요한 경우엔 Javscript SDK를 로드하는 스크립트 태그가 메인 어플리케이션 스크립트 앞에 나타나야 합니다.
+
+### Splash screens
+스플래시 스크린은 기본적으로 구현됩니다. 만약 스플래쉬 스크린을 삭제하거나 커스터마이징 하려면 주의가 필요한 몇 가지 기능이 있습니다.
+
+\+ HTML 마크업 \+ CSS 스타일 \+ Javascript 로직
+
+Javascript를 직접 구현하는 것은 선택사항이지만, 만약 아래 함수를 포함하는 "SplashControl" 오브젝트를 구현하면 Defold 어플리케이션이 이와 관련된 정보를 돌려보내 줍니다.
+
+#### onSetMessage(text)
+이 콜백(callback)은 유저에게 표시하려는 텍스트를 수신합니다.
+
+####onSetProgress(current, max)
+어플리케이션이 로드될 때, 이 콜백은 현재 진행률(current progress)을 받습니다. "current"는 로드된 데이터의 양을 가지고 있고 "max"는 로드 할 전체 데이터의 양을 가지고 있습니다.
+
+#### onDismissSplash()
+이 콜백은 어플리케이션이 로드 되어 실행을 시작하고 캔버스를 렌더링(스플래시 스크린이 닫힐 때) 하려 할 때 어플리케이션에 의해 호출됩니다.
+
+또한 기본 구현에는 윈도우 리사이징 이벤트를 다루는 로직도 포함하고 있습니다. 이 구현은 변경하거나 교체하려면, 메인 모듈이 제공하는 아래 두가지 헬퍼 함수를 사용할 수 있습니다.
+
+#### Module.matchToCanvas(id)
+DOM 요소의 id를 받아서 캔버스의 비율에 맞게 "width"와 "height" 속성을 조정합니다. "marginTop" 속성은 브라우저 윈도우의 캔버스를 세로 정렬하는데 사용됩니다.
+
+#### Module.setMarginTop(id, sourcePixels)
+"id" 요소의 "marginTop" 속성을 프로젝트 설정의 어플리케이션 높이와 관련된 스케일값으로 표시된 "sourcePixels" 값으로 설정합니다. 내부적으로 "sourcePixels"는 top margin에 할당되기 전에 스케일 값에 곱해집니다. 이 스케일 값은 실제 브라우저 창의 픽셀 높이에서 어플리케이션 픽셀 높이를 프로젝트 셋팅에 지정한 대로 나눕니다.
+
+> 이 메소드들은 모듈 스크립트가 다 로드되기 전까지는 사용할 수 없습니다. 사용 예제는 기본으로 생성된 HTML 파일을 참고하시기 바랍니다.
+
+> 스플래시 스크린 개발에 중점을 둘 경우, 로딩과 실행에 관련된 코드들을 주석처리 해서 프로세스 속도를 높일 수 있습니다.
+
+### Tokens
+HTML5 어플리케이션을 생성할 때, HTML과 CSS 파일들은 특정 토큰을 프로젝트 설정에 의존하는 값으로 교체할 수 있는 컴파일러를 통해 전달됩니다. 이 토큰은 문자 시퀀스를 이스케이프 해야하는지 말아야 하는지에 따라 항상 이중 혹은 삼중 중괄호(‘{ }‘)로 묶습니다. 이 기능은 프로젝트 설정을 자주 변경하거나 다른 프로젝트에서 메터리얼을 재사용 하려는 경우에 유용합니다.
+
+HTML이나 CSS 컨텐츠에 따라, 아래 토큰들이 모두 지원됩니다.
+
+#### DEFOLD_DISPLAY_WIDTH
+(HTML 또는 CSS) 프로젝트 설정에 지정된 값을 display width에 씁니다.
+```
+function doSomething() {
+    var x = {{DEFOLD_DISPLAY_WIDTH}};
+    // ...
+}
+```
+
+#### DEFOLD_DISPLAY_HEIGHT
+(HTML 또는 CSS) 프로젝트 설정에 지정된 값을 display height에 씁니다.
+```
+function doSomething() {
+    var y = {{DEFOLD_DISPLAY_HEIGHT}};
+}
+```
+
+#### DEFOLD_SPLASH_IMAGE
+(HTML 또는 CSS) 스플래시 이미지 파일의 파일명을 씁니다.
+```
+<image class="splashImage" src="{{DEFOLD_SPLASH_IMAGE}}"></image>
+```
+
+아래 토큰들은 HTML 파일을 처리할 때에만 지원됩니다.
+
+#### DEFOLD_APP_TITLE
+(HTML) 프로젝트의 타이틀에 기반한 문자열을 생성합니다.
+```
+<head>
+<title>{{DEFOLD_APP_TITLE}}</title>
+</head>
+```
+
+#### DEFOLD_JS
+(HTML) 메인 어플리케이션의 자바스크립트 파일 이름과 일치됩니다.
+
+#### DEFOLD_MODULE_JS
+(HTML) 부트스트랩 자바스크립트 파일 이름과 일치됩니다. 이 파일은 어플리케이션 에셋을 로드하고 스플래시 이미지의 활동을 조정합니다.
+```
+<script type='text/javascript' src="{{DEFOLD_MODULE_JS}}"></script>;
+```
+
+#### DEFOLD_CSS
+(HTML) 프로젝트 설정에 지정된 기본 또는 템플릿을 익스포트하는 동안 출력되는 CSS 파일의 파일명입니다.
+```
+<head>
+<link rel="stylesheet" type="text/css" href="{{DEFOLD_CSS}}"></style>
+</head>
+```
+
+#### DEFOLD_DEV_HEAD
+(HTML) 프로젝트 설정에 따라 HTML 문서의 <head>섹션에서 사용되는 커스텀 HTML 조각을 생성합니다. 이 문자 시퀀스를 이스케이프 하면 안되기 때문에 3중 중괄호(triple braces)를 사용해야 합니다.
+
+```
+<head>
+{{{DEFOLD_DEV_HEAD}}}
+</head>
+```
+
+#### DEFOLD_DEV_INLINE
+(HTML) 프로젝트 설정에 따라 HTML 문서의 <body>섹션에서 사용되는 커스텀 HTML 조각을 생성합니다.
+```
+{{{DEFOLD_DEV_INLINE}}}
+<script type="text/javascript" src="//connect.facebook.net/en_US/sdk.js"></script>
+<!-- etc. -->
+```
+
+> 이 인라인 블록(inline block)은 메인 어플리케이션 스크립트를 로드하기 전에 있어야 합니다. HTML 태그가 포함되어 있기 때문에 이 매크로는 문자 시퀀스가 이스케이프 되지 않도록 3중 중괄호를 써야 합니다.
+
+#### DEFOLD_JS_INIT
+(HTML) 이 태그는 일단 처리되면 Defold 어플리케이션을 로드하기 위한 코드를 추가합니다. 이를 위해선 development options을 활성화 해야 하며, 관계된 모듈들의 초기화를 수행해야 합니다.
+```
+{{{DEFOLD_DEV_INLINE}}}
+<script type="text/javascript" src="//connect.facebook.net/en_US/sdk.js"></script>
+{{{DEFOLD_JS_INIT}}}
+```
+
+> 만약 Facebook SDK 를 사용하려 한다면 이 태그를 로드하기 위해 "DEFOLD_JS_INIT" 태그 앞에 있어야 합니다. 또한 이 매크로는 HTML 태그가 포함되어 있으므로 이스케이프 하지 않기 위해 3중 중괄호로 둘러 싸야 합니다.
+
+## HTML5 Memory Tracker
+개발 중에는 간단한 메모리 추적 도구를 포함하는 HTML5 번들을 생성할 수 있습니다. 어플리케이션에 이 도구를 포함시키기 위해서는 우선 "game.project" 파일을 열어 **html5** 섹션으로 이동해야 합니다.
+
+![Include devtool](images/html5/html5_devtool_include.png)
+
+**include_dev_tool** 옵션을 체크하면 번들 작업이 수행될 때 이 도구를 자동으로 활성화 하고 포함시킵니다.
+
+> 릴리즈 버전을 생성하기 전에는 이 옵션을 해제해야 합니다.
+
+### Tool features
+브라우저에서 어플리케이션을 정상적으로 실행하면 이 도구가 화면에 나타나게 됩니다.
+
+![Devtool example](images/html5/html5_devtool_goatgold.png)
+
+토글 버튼을 눌러서 다양한 메모리 리포팅 섹션을 활성화 하고 비활성화 할 수 있습니다. 이 섹션들은 아래의 정보를 포함하고 있습니다.
+
+#### Heap
+힙 메모리의 전체 사이즈입니다. 이 값은 custom heap size 설정에 의해 구성될 수도 있습니다. 이 값을 튜닝하면 리소스를 최적으로 사용하는 릴리즈 버전을 만들 때 유용합니다.
+#### Dynamic
+동적 메모리 할당의 최대치와 현재 수치 및 전체 할당 횟수와 어플리케이션에 의해 수행된 작업의 수를 측정합니다.
+#### Static
+어플리케이션에 직접 빌드된 데이터를 포함하는 정적 메모리 할당을 요약합니다.
+#### Stack
+스택 사용을 위한 코드에 할당된 메모리 총합을 모니터링합니다. 사용된 값이 0으로 보고되면 정상 작동 중이며, 다른 값이면 엔진에 버그가 있음을 나타냅니다.
+
+처음 두 섹션은 개발 과정중에 큰 관련이 있을 가능성이 큽니다. 특히, 성능이 우수한 어플리케이션은 동적 메모리 할당을 자주 요청하지 않습니다.
+
+### Known limitations
+이 메모리 추적 도구는 malloc() 와 free() 함수를 패치해서 작동하며 가능한 빨리 실행됩니다. 이 패치는 메소드가 전역 생성자로 선언되기 이전에 수행되지는 않습니다. 즉, 어플리케이션의 초기 단계에서 일어난 동적 할당은 데이터 사용량(usage)과 피크(peak)를 추적할 수 없습니다. 하지만 동적 메모리 영역과 위치에 관련된 값은 정확하게 추적 가능합니다.
+

docs/ko/manuals/iap.md

@@ -0,0 +1,173 @@
+# In-app purchases
+인-앱 구매 (또는 인-앱 결제)는 유저나 플레이어에게 추가 컨텐츠나 추가 기능에 대한 비용을 청구할 수 있습니다. 이 매뉴얼은 이 기능을 위한 Defold API를 설명합니다.
+
+Defold는 Apple의 iOS 앱 스토어의 "in-app purchases" 와 Android 장치에서 Google Play 또는 Amazon의 "in-app billing"를 위한 심플하고 통일된 인터페이스를 제공합니다.
+Facebook Canvas "game payments"는 Facebook Canvas에서 지원됩니다. 이들 서비스는 다음과 같이 제품을 판매할 수 있는 기회를 제공합니다.
+
+* 소모성 또는 비소모성의 표준 인-앱 제품 (1회 결제)
+* 구독(Subscription) (반복 결제, 자동 결제)
+
+> 현재 Defold 인터페이스는 Apple의 Storekit 기능과 완벽히 상호작용 됩니다. Google Play와 Facebook Canvas의 경우는 인터페이스는 동일하므로 각 플랫폼에서 동일한 코드를 실행할 수 있습니다. 하지만 일부 프로세스 흐름은 플랫폼 마다 다를 수 있습니다. 또한, 현재 Mac Appstore를 통핸 OS X 구매는 지원되고 있지 않습니다.
+
+Apple, Google, Amazon, Facebook 에서 자세한 설명을 볼 수 있습니다.
+
+* [In-App Purchase Programming Guide.](https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/StoreKitGuide/Introduction.html)
+* [Google Play In-app Billing documentation.](http://developer.android.com/google/play/billing/index.html)
+* [Amazon In-app Purchase documentation.](https://developer.amazon.com/public/apis/earn/in-app-purchasing)
+* [Facebook game payments documentation.](https://developers.facebook.com/docs/payments)
+
+## Testing Google Play Billing with static responses
+Android 에서는 Google Play 로부터 정적 응답(static responses)을 사용하여 앱에서 IAP 구현을 시작하는 것을 추천합니다. 이렇게 하면 앱을 게시하기 전에 모든 앱의 동작이 제대로 돌아가는지 인증하는 것을 활성화 할 수 있습니다. 여기엔 정적 인앱 빌링 응답(static In-app Billing responses)을 테스트하기 위한 4개의 예약된 프로덕트 아이디가 있습니다.
+
+#### android.test.purchased
+Google Play는 아이템이 성공적으로 결제되었는지 응답합니다. 이 응답은 가짜 구매 정보 (예, 가짜 order ID)도 포함한 JSON 문자열을 포함하고 있습니다.
+#### android.test.canceled
+Google Play는 결제가 취소되었는지 응답하니다. 이는 유효하지 않은 신용카드이거나 결제 직전에 사용자가 주문을 취소 하는 등의 주문 과정 중 에러가 발생했을 때 나타날 수 있습니다.
+#### android.test.refunded
+Google Play는 결제가 환불 되었는지 응답합니다.
+#### android.test.item_unavailable
+Google Play는 구매중인 아이템이 사용자의 어플리케이션 제품 목록에 없을 경우 응답합니다.
+
+## Setting up your app for purchases/billing
+iOS 와 Android 의 구매 절차는 비슷합니다.
+
+1. Apple 이나 Google Play 의 개발자로 등록되었는지 확인합니다.
+
+2. 대상 디바이스(target device)에서 동작하도록 프로젝트를 설정합니다. [iOS development](http://www.defold.com/manuals/ios) 그리고 [Android development](http://www.defold.com/manuals/android) 가이드를 참고하세요.
+
+3. 테스트용 앱을 설정합니다:
+    * Android는 [Google Play Developer Console](https://play.google.com/apps/publish/) 에서 할 수 있습니다.
+    * iOS는 [iTunes Connect](https://itunesconnect.apple.com/) 에서 할 수 있습니다. App ID (https://developer.apple.com 의 "Member Center"에서 만들었던) 에서 "In-App Purchase" 가 활성화 되어있는지 확인하십시오.
+![iTunes Connect and Google Play Dev Console](images/iap/itunes_connect_google_play.png)
+
+4. Google Play의 경우, 알파 **.apk** 파일을 업로드하고 게시(publish)해야 합니다. iTunes Connect의 경우에는 어플리케이션이 App Review 승인을 받을 때 까지는 바이너리를 업로드 하지 마십시오. iTunes Connect에 업로드 했는데 제대로 동작하지 않는다면 Apple이 이를 리젝(reject)할 수도 있습니다.
+
+5. 앱을 위한 프로덕트를 생성합니다.
+![iTunes Products](images/iap/itunes_products.png)
+--
+![Google Play Products](images/iap/google_play_products.png)
+
+6. 테스트 사용자를 추가합니다.
+    *  iTunes Connect 페이지의 **Users and Roles**에서는 샌드박스 환경에서 결제를 테스트할 수 있는 사용자를 추가할 수 있습니다. Developer 인증서를 앱에 서명하고 테스트 장치의 Appstore에서 샌드박스 계정을 사용해야 합니다.
+
+    * Google Play Developer Console 에서는 **Settings > Account Details** 에서 License Testing 섹션에 사용자 이메일을 추가할 수 있습니다. 이메일은 쉼표(,)로 구분해 여러 이메일을 추가할 수 있으며, 이 사용자들은 실제 돈을 결제하지 않고 구매 절차를 테스트 할 수 있습니다.
+
+    * 또한 Google Play 에서는 Google Group 을 설정해서 Alpha와 Beta 스토어에서 앱을 다운로드 할 수 있게 테스터 그룹을 관리할 수도 있습니다. **Alpha Testing** 탭을 클릭하고 **Manage list of testers**를 눌러서 Alpha 테스터로 Google Group을 추가한 후 나타나는 링크를 공유하면 됩니다.
+
+![Alpha testers](images/iap/alpha_testers.png)
+
+Facebook에서의 절차:
+
+1. [Facebook developer](https://developers.facebook.com/) 에 등록되어 있는지 확인합니다. Facebook for developers의 "My Apps" 과 "Register as a developer" 단계를 따라 하십시오.
+
+2. Facebook은 폭넓은 결제 기능을 가지고 있으며 동기식(synchronous)과 비동기(asynchronous)식 결제를 지원하는 것을 요구하고 있습니다. 더 많은 정보는 [Payment overview](https://developers.facebook.com/docs/payments/overview) 에서 확인 바랍니다.
+
+3. 앱 호스팅(app hosting)과 콜백 서버(callback server)를 설정합니다:
+    * 프로젝트를 호스팅하는 secure canvas URL을 설정해야 합니다. 자세한 설명은 [Games on Facebook](https://developers.facebook.com/docs/games/gamesonfacebook/hosting) 에서 볼 수 있습니다.
+    * 다음으로 콜백 서버를 설정하기 위해 [Setting up your callback server](https://developers.facebook.com/docs/payments/realtimeupdates#yourcallbackserver) 단계를 수행해 주십시오.
+
+4. [Facebook Developer Dashboard](https://developers.facebook.com/quickstarts/?platform=canvas)에서 캔버스 앱(canvas app)을 설정합니다.
+
+5. 앱 대쉬보드의  "Canvas Payments"에서 테스트 사용자를 추가합니다.
+
+6. [Defining products](https://developers.facebook.com/docs/payments/implementation-guide/defining-products/) 에서 프로덕트 앱을 생성합니다.
+
+## Asynchronous transactions
+IAP API는 비동기 방식입니다. 즉 프로그램이 서버로 각 요청을 보낸 후에도 프로그램을 중단하지 않은 채로 응답을 기다리는 것을 말합니다. 대신 프로그램은 정상적으로 동작하며 응답이 도착하면 이 응답 데이터에 반응하는 콜백 함수(callback function)가 호출(invoke)됩니다.
+
+사용가능한 모든 제품 목록을 가져오려면 아래와 같이 할 수 있습니다.
+
+```lua
+local COINS_ID = "com.defold.examples.coins"
+local LOGO_ID = "com.defold.examples.logo"
+
+local function product_list(self, products, error)
+    if error == nil then
+        for i,p in pairs(products) do
+            print(p.ident)
+            print(p.title)
+            print(p.description)
+            print(p.currency_code)
+            print(p.price_string)
+        end
+    else
+        print(error.error)
+    end
+end
+
+function init(self)
+    -- Initiate a fetch of products
+    iap.list({ COINS_ID, LOGO_ID }, product_list)
+end
+```
+
+실제 트랜잭션을 수행하려면, 먼저 트랜잭션 결과를 수신하는 함수를 등록하고 적당한 때에 이 함수를 호출하면 됩니다.
+
+```lua
+    local function iap_listener(self, transaction, error)
+        if error == nil then
+            if transaction.state == iap.TRANS_STATE_PURCHASING then
+                print("Purchasing...")
+            elseif transaction.state == iap.TRANS_STATE_PURCHASED then
+                print("Purchased!")
+            elseif transaction.state == iap.TRANS_STATE_UNVERIFIED then
+                print("Unverified!")
+            elseif transaction.state == iap.TRANS_STATE_FAILED then
+                print("Failed!")
+            elseif transaction.state == iap.TRANS_STATE_RESTORED then
+                print("Restored")
+            end
+        else
+            print(error.error)
+        end
+    end
+
+    function on_message(self, message_id, message, sender)
+
+        ...
+        -- IAP 트래잭션을 수신하는 함수를 등록하기
+        iap.set_listener(iap_listener)
+        -- 코인 구매 초기화하기
+        iap.buy(COINS_ID)
+        ...
+
+    end
+```
+
+장치의 운영체제는 사용자가 구매를 할 수 있는 팝업창을 자동으로 띄워줍니다. 이 인터페이스는 테스트/샌드박스 환경에서 실행중인지 여부를 보여줍니다.
+
+![Confirm purchase](images/iap/ios_confirm_purchase.png)
+
+![Android purchase](images/iap/android_purchase.png)
+
+![Confirm purchase](images/iap/ios_purchase_done.png)
+
+## Synchronous payments
+대부분의 결제 제공자(payment providers)는 동기식 결제만을 지원합니다. 즉 클라이언트(당신의 어플리케이션)은 결제가 완료될 때 TRANS_STATE_PURCHASED 와 같은 알림을 받는다는 것을 뜻합니다. 이는 결제의 마지막 상태(final state)이며 이 트랜잭션에서 더 이상의 콜백을 제공하지 않습니다.
+
+## Asynchronous payments
+일부 결제 제공자는 비동기 결제를 지원할 것을 요구하고 있습니다. 즉 클라이언트(당신의 어플리케이션)은 결제가 초기화 될 때만 알림을 받을 수 있습니다. 결제 완료를 확인하기 위해서는 개발자 서버(또는 클라이언트)와 통신하여 결제가 유효한지 확인해야 합니다. 비동기 결제를 초기화 했을 경우 iap 수신자(iap listener)는 TRANS_STATE_UNVERIFIED 또는 TRANS_STATE_PURCHASED 를 받을 수 있습니다. 이는 결제의 마지막 상태(final state)이므로 이 트랜잭션에서 더 이상의 콜백을 제공하지 않습니다.
+
+## Purchase fulfillment
+결제 제공자로부터 구매를 완료하기 위해서는, 어플리케이션은 구매 이행서(purchase fulfillment)를 결제 제공자에게 알릴 필요가 있습니다.(예: 개발자 서버 사이드에서 확인). 
+Iap는 구매가 완료될 경우(기본 동작) 공급자에게 자동으로 이행서(fulfillment)를 알려주는 자동-완성 기능을 지원합니다. 또한 game project 설정에서 이 기능을 비활성화 할 수도 있습니다. 그러면 트랜잭션이 완료될 때 iap.finish()를 호출해서 구매 이행서를 제공자에게 넘길 수 있습니다.
+
+## Transaction receipt
+영수증(receipt)은 결제가 성공적으로 처리되었는지 확인하기 위해서 App Store로 전송하는 서명된 데이터의 묶음(chunk)입니다. 이는 별도의 서버를 사용하여 결제 진행을 확인하는 상점을 설계할 때 매우 유용합니다.
+
+## Troubleshooting
+### Android iap.list()가 "failed to fetch product"를 리턴합니다.
+Google Play Developer Console 의 alpha나 beta 채널에 **.apk**를 업로드하고 게시(publish)해야 합니다. 또한 당신의 장치의 시간이나 날짜가 정확한지 확인해 보세요.
+
+### iOS iap.list() 가 아무것도 리턴하지 않습니다.
+iOS Paid Applications 계정을 요청해서 올바른 문서가 제출되었는지 확인합니다. 적절한 승인(authorization) 없이는 iOS 앱 구매(테스트 구매도)가 제대로 동작하지 않습니다.
+
+"Member Center" 의 AppId에서 in-app purchases가 활성화(activated)되어 있는지 확인하고 앱(또는 dev-app)에 프로비져닝 프로파일이 AppId와 올바른 날짜로 서명되어 있는지 확인합니다. ("Member Center"의 "Certificates, Identifiers & Profiles"에서 provisioning profile details 의 "Enabled Services:" 필드 확인)
+
+여기서 In-App product ID가 샌드박스 환경으로 전파되는데 몇 시간이 걸릴 수도 있습니다.
+
+### iOS iap.list() fails logging error "Unexpected callback set"
+iap.list는 중첩 호출(nested calls)를 지원하지 않습니다. iap.list 콜백함수에서 iap.list 를 호출하는 것은 이 에러를 수집하는 엔진에서 무시하게 됩니다.
+
+### On iOS, the "price_string" field contains ~ characters
+~ 문자는 폰트 파일에서 일치하는 문자를 찾을 수 없는 placeholders입니다. iap.list()를 사용하는 경우 제품 목록에서 반환된 "price_string" 필드는 이 값과 화폐 분모(currency denominator) 사이에서 줄 바꿈 없는 공백(non breaking space (\u00a0))으로 형식화 됩니다. 만약 GUI에서 이 문자열을 렌더링하려면, 폰트의 **extra_characters** 필드에 이 문자를 추가할 필요가 있습니다. Mac OS X에서는 줄 바꿈 없는 공백(non breaking spaces)을 **Option-\<SPACE>** 를 눌러서 입력할 수 있습니다. 자세한 정보는  [https://ko.wikipedia.org/wiki/줄 바꿈 없는 공백](https://ko.wikipedia.org/wiki/줄%20바꿈%20없는%20공백) 를 확인 바랍니다.