Removed obsolete translations.

src/docs/asciidoc/documentacao.adoc

@@ -1,106 +0,0 @@
-= Documentação jMonkeyEngine
-:author:
-:revnumber:
-:revdate: 2016/03/17 20:48
-:keywords: documentation, sdk, install
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Essa wiki contém guias de instalação e configuração, tutoriais de codificação jME3 e outras informaçõess que lhe ajudarão a dar andamento no seu projeto de jogo. Você pode pesquisar o conteúdo dessa wiki usando a caixa de pesquisa “Search localizado na direita-superior dessa página.
-
-Você também é convidado a corrigir equívicos ou problemas de digitação, como também parágrafos confusos, usando o menu “Tools localizado na direita-superior dessa página ou o botão “Edit em cada parágrafo. Você precisa estar conectado na wiki para poder editar.
-
-
-== Instalação
-
-*Antes de instalar, verifique a <<bsd_license#,licença>>, <<jme3/features#,funcionalidades>>, e <<jme3/requerimentos#,requerimentos>>.* Então, escolha uma das seguintes opções:
-[cols="4", options="header"]
-|===
-
-a|
-<a| Recomendado
-<a| Opcional
-<a| Opcional
-
-a| Você gostaria de…
-a| Iniciar com a jMonkeyEngine
-a| Usar a jMonkeyEngine em outra IDE
-a| Construir uma “engine a partir do código fonte
-
-a| Então baixe…
-a| link:https://github.com/jMonkeyEngine/sdk/releases/tag/stable[jMonkeyEngine SDK]
-a| link:https://github.com/jMonkeyEngine/sdk/releases[Binaries]
-a| link:https://github.com/jMonkeyEngine/jmonkeyengine[Sources]
-
-a| Você receberá…
-a| Fontes, binários, javadoc, SDK
-a| Ultima versão estável, fontes, javadoc.
-a| Fontes
-
-a| Aprenda mais…
-a| <<sdk#,Utilizando o SDK>> +<<sdk/project_creation#,Criação de Projeto>> +
-image::sdk/jme3-jmonkeyplatform.png[jme3-jmonkeyplatform.png,width="144",height="90",align="center"]
-
-a| <<jme3/maven#,Configurando o JME3 com IDE compatívels com maven>> * +<<jme3/setting_up_netbeans_and_jme3#,Configurando o JME3 no NetBeans IDE>> * +<<jme3/setting_up_jme3_in_eclipse#,Configurando o JME3 no Eclipse IDE>> * +<<jme3/eclipse_jme3_android_jnindk#,Configurando o JME3 no Eclipse IDE (com Android e/ou JNI/NDK)>> *
-a| <<jme3/build_from_sources#,Compilando JME3 a partir dos Fontes>> +<<jme3/build_jme3_sources_with_netbeans#,Compilando jME3 a partir dos Fontes com NetBeans>> +<<jme3/simpleapplication_from_the_commandline#,Configurando o jME3 na linha de comando>>
-
-|===
-
-(*) O SDK cria projetos baseados em ANT que qualquer Java IDE pode importar. Nós recomendamos que usuários de outras IDEs baixem a jMonkeyEngine SDK e escolham “Arquivo→Importar Projeto→Pastas de Projeto Externo para criar um projeto sem código, apanas para gerenciar os assets. Dessa forma, você pode codificar no IDE de sua escolha e ainda utilizar o SDK para converter seus modelos para o formato .j3o.
-
-* EM CONSTRUÇÃO *
-
-
-== Crie
-
-Depois de baixado e instalado, <<jme3#,adicione esta página em seus favoritos>> e comece a escrever seu primeiro jogo!
-[cols="3", options="header"]
-|===
-
-a| Tutoriais
-a| jMonkeyEngine SDK
-a| Outras Documentações
-
-a| <<jme3#tutorials_for_beginners,jME3 tutoriais para iniciantes>>
-a| <<sdk#,Documentação jMonkeyEngine SDK e Vídeo Tutoriais>>
-a| link:http://javadoc.jmonkeyengine.org/[API JavaDoc Completa]
-
-a| <<jme3#documentation_for_intermediate_users,Artigos jME3 intermediário>>
-a| <<sdk/comic#,jMonkeyEngine SDK - a Comédia :-)>>
-a| <<jme3/external/blender#,Guia de Modelagem em Blender>>
-
-a| <<jme3#documentation_for_advanced_users,jME3 documentação avançada>>
-<a|
-a| <<jme3/faq#,Respostas para Perguntas Frequentes>>
-
-|===
-
-
-== Contribua
-
-Você é um desenvolvedor Java experiente que quer adicionar novas funcionalidades ou contribuír com o projeto jME3?
-
-*  Inspire-se com <<jme3/contributions#,contribuições>> existentes
-*  link:http://hub.jmonkeyengine.org/introduction/contributors-handbook/[Leia o guia dos Contribuídores]
-*  link:http://hub.jmonkeyengine.org/[Grite no fórum dos Contribuídores]
-*  <<jme3/jme3_source_structure#,Aprenda sobre a estrutura dos Fontes>>
-*  <<sdk#development,Escreva plugins e editores visuais para a jMonkeyEngine SDK>>
-*  <<report_bugs#,Reporte bugs e envie correções>>
-
-
-== Contato
-
-Você é bem-vindo em contribuír ou perguntar sobre o projeto: Por favor mailto:&#x63;&#x6f;&#x6e;&#x74;&#x61;&#x63;&#x74;&#x40;&#x6a;&#x6d;&#x6f;&#x6e;&#x6b;&#x65;&#x79;&#x65;&#x6e;&#x67;&#x69;&#x6e;&#x65;&#x2e;&#x63;&#x6f;&#x6d;[contate] os
-link:http://jmonkeyengine.org/team/[desenvolvedores] ou pergunte no link:http://hub.jmonkeyengine.org/[fórum].
-
-*  mailto:&#x63;&#x6f;&#x6e;&#x74;&#x61;&#x63;&#x74;&#x40;&#x6a;&#x6d;&#x6f;&#x6e;&#x6b;&#x65;&#x79;&#x65;&#x6e;&#x67;&#x69;&#x6e;&#x65;&#x2e;&#x63;&#x6f;&#x6d;[Contate o time jME]
-**  link:http://jmonkeyengine.org/team/[Core Team - Quem somos?]
-
-*  <<report_bugs#,Reporte uma falha>>
-*  link:http://hub.jmonkeyengine.org/c/documentation-jme3[Reporte documentação confusa ou faltante]
-
-
-== Línguas
-
-<<документация#,Документация на Русском>>
-<<documentacao#,Documentação em Português>>

src/docs/asciidoc/documentation.adoc

@@ -117,5 +117,4 @@ You are welcome to contribute and inquire about the project: Please contact the
 
 The team is looking for other monkeys that would be interested in a wiki translation of [insert your favorite language here]. If you're interested in hosting translations see <<wiki\wiki_translation.adoc#,Wiki Translation Repositories>>.
 
-<<documentacao#,Documentação em Português>> +
 link:http://www.jmecn.net/wiki/[简体中文]

src/docs/asciidoc/documentation_de.adoc

@@ -1,104 +0,0 @@
-= Einführung in die jMonkeyEngine 3.0
-:author:
-:revnumber:
-:revdate: 2016/03/17 20:48
-:keywords: documentation, sdk, install
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-*Du bist Java Entwickler und möchtest 3D Spiele schreiben, die auf Windows, Mac, Linux, im Webbrowser, und auf der Android Plattform laufen? Dann bist du hier richtig! Das jMonkeyEngine Framework (jME) ist eine leistungsstarke, 3D Szenen-basierte Grafik +++<abbr title="Application Programming Interface">API</abbr>+++ mit <<jme3/features#,modernen Features>>.*
-
-Die jMonkeyEngine 3 ist ein Bündel aus JAR Dateien, das du in den Java Classpath platzierst. Die Software ist in Java geschrieben und nutzt LWJGL für den Zugriff auf OpenGL. Die jMonkeyEngine Open Source Community gibt diese Bibliotheken lizensiert unter der <<bsd_license#,BSD Lizenz>> heraus, welche sie jedem frei zur Verfügung stellt, so wie er sie benötigt – sei es für das eigene Hobby, für Lehrzwecke, oder kommerziell.
-
-Die dritte Version der jMonkeyEngine ist nun im Beta Stadium. Du nutzt noch die link:http://jme2.jmonkeyengine.org/[jME2]? Dann lies doch bitte unsere <<choose-jme2-or-jme3#,Begründung für die Wahl der jME2 oder jME3>> und den <<compare-jme2-jme3#,jME2/jME3 Feature-Vergleich>> und beginne mit dem Portieren zur jME3.
-
-
-== Was ist das jMonkeyEngine SDK?
-
-Das link:http://jmonkeyengine.org/downloads/[jMonkeyEngine3 SDK] ist ein vorkonfiguriertes Software-Entwicklungskit, maßgeschneidert für Java Spielentwickler. Das SDK kombiniert alle jME3 Bibliotheken und einige <<sdk#,einmalige Entwickler Werkzeuge>>, die dir das Leben leichter machen, wenn du in Java programmierst und deine Projekte managst. Das SDK beinhaltet Projekt- und Dateiassistenten, einen erweiterten Code Editor, Spieldaten-Management, Dateikonverter, Szenenbetrachter und -designer, eine Codeschnipselablage, einen Terrain-Editor, und vieles mehr.
-
-
-=== Installation
-
-*Bevor du die Installation startest, lies dir die <<bsd_license#,Lizenz>> durch, <<jme3/features#,die jME3 Features>>, und die <<jme3/requirements#,Systemanforderungen>>.* Wähle dann eine der folgenden Optionen:
-[cols="4", options="header"]
-|===
-
-a|
-<a| Empfohlen
-<a| Optional
-<a| Optional
-
-a| Du möchtest …
-a| Dich mit der jMonkeyEngine vertraut machen
-a| Die jMonkeyEngine in einer anderen IDE nutzen
-a| Eine benutzerdefinierte Engine aus dem Quellcode erstellen
-
-a| Dann downloade …
-a| link:https://github.com/jMonkeyEngine/sdk/releases/tag/stable[jMonkeyEngine SDK]
-a| link:https://github.com/jMonkeyEngine/sdk/releases[Binaries]
-a| link:https://github.com/jMonkeyEngine/jmonkeyengine[Sources]
-
-a| Du bekommst …
-a| Quellcode, binäre Dateien, JavaDoc, SDK
-a| Den aktuellsten nightly build, Quellcodes, JavaDoc.
-a| Quellcodes
-
-a| Erfahre mehr …
-a| <<sdk#,Benutzung des SDK>> +<<sdk/project_creation#,Projekte erstellen>> +
-image::sdk/jme3-jmonkeyplatform.png[jme3-jmonkeyplatform.png,width="144",height="90",align="center"]
-
-a| <<jme3/setting_up_netbeans_and_jme3#,Nutzung der jME3 in NetBeans>> * +<<jme3/setting_up_jme3_in_eclipse#,Nutzung der jME3 in Eclipse>> *
-a| <<jme3/build_from_sources#,Kompilieren der jME3 aus den Quellcodes>> +<<jme3/build_jme3_sources_with_netbeans#,Kompilieren der jME3 aus den Quellcodes mit NetBeans>> +<<jme3/simpleapplication_from_the_commandline#,Einrichtung der jME3 über die Kommandozeileneingabe>>
-
-|===
-
-(*) Das SDK erstellt Ant-basierte Projekte, welche jede Java IDE importieren kann. Wir empfehlen Benutzern anderer IDEs sich ebenfalls das jMonkeyEngine SDK herunterzuladen und die Spieldaten dann zu importieren (File→Import Project→External Project Assets), um die Spieldaten gesondert verwalten zu können, ohne Code. So kannst du mit der IDE deiner Wahl Code schreiben, und gleichzeitig das SDK nutzen, um deine Modelle in das .j3o Format zu konvertieren.
-
-
-=== Entwicklung des ersten, eigenen Spiels
-
-Nachdem du alles heruntergeladen und installiert hast, <<jme3#,lege dir ein Lesezeichen für die jME3 Dokumentation an>>. Dann kann es auch schon losgehen mit der Entwicklung deines ersten, eigenen Spiels! ;)
-[cols="3", options="header"]
-|===
-
-a| Tutorials
-a| jMonkeyEngine SDK
-a| Andere Dokumentationen
-
-a| <<jme3#tutorials_for_beginners,jME3 Einsteiger Tutorial>>
-a| <<sdk#,jMonkeyEngine SDK Dokumentation und Video Tutorials>>
-a| link:http://jmonkeyengine.org/javadoc/[Komplettes API JavaDoc]
-
-a| <<jme3#documentation_for_intermediate_users,jME3 Doku für geübte Benutzer>>
-a| <<sdk/comic#,jMonkeyEngine SDK - der Comic :-)>>
-a| <<jme3/faq#,Antworten zu häufig gestellten Fragen>>
-
-a| <<jme3#documentation_for_advanced_users,jME3 Doku für fortgeschrittene Benutzer>>
-a|
-a|
-
-|===
-
-
-=== Wenn du etwas beitragen möchtest
-
-Du bist ein erfahrener Java Entwickler und möchtest neue Features oder Verbesserungen in das jME3 Projekt einbringen?
-
-*  link:http://jmonkeyengine.org/introduction/contributors-handbook/[Lies das Mitarbeiter Handbuch]
-*  link:http://www.jmonkeyengine.com/forum/index.php?board=30.0[Klinke dich im Mitarbeiter Forum ein]
-*  <<jme3/jme3_source_structure#,Lerne die Quellcode Strukturen kennen>>
-*  <<sdk#development,Schreibe Plugins für das jME SDK und visuelle Editoren>>
-*  <<report_bugs#,Melde Fehler und reiche Patches ein>>
-
-
-=== Kontakt
-
-Gerne darfst du unser Projekt unterstützen, oder Fragen dazu stellen: Bitte mailto:&#x63;&#x6f;&#x6e;&#x74;&#x61;&#x63;&#x74;&#x40;&#x6a;&#x6d;&#x6f;&#x6e;&#x6b;&#x65;&#x79;&#x65;&#x6e;&#x67;&#x69;&#x6e;&#x65;&#x2e;&#x63;&#x6f;&#x6d;[kontaktiere] die link:http://jmonkeyengine.org/team/[Entwickler] oder frage im link:http://jmonkeyengine.org/forums[Forum] nach.
-
-*  mailto:&#x63;&#x6f;&#x6e;&#x74;&#x61;&#x63;&#x74;&#x40;&#x6a;&#x6d;&#x6f;&#x6e;&#x6b;&#x65;&#x79;&#x65;&#x6e;&#x67;&#x69;&#x6e;&#x65;&#x2e;&#x63;&#x6f;&#x6d;[Schreibe dem jME Team eine Mail!]
-**  link:http://jmonkeyengine.org/team/[Das Kern-Team - Wer sind wir?]
-**  link:http://jmonkeyengine.org/groups/contributor/members/[Mitarbeiter - Wer sind wir?]
-
-*  <<report_bugs#,Du hast einen Fehler gefunden? Hier kannst du ihn melden!>>
-*  link:http://code.google.com/p/jmonkeyengine/issues/list?can=2&q=label:Component-Docs[Es fehlt etwas in der Doku? Bitte gib uns bescheid!]

src/docs/asciidoc/jme3/beginner/chinese_translation_standardization.adoc

@@ -1,26 +0,0 @@
-= chinese_translation_standardization
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-This is the JME3 Chinese to English standardization for programming terms such as instantiate or instance. This is here so that all of the Chinese tutorials will use the same word choice. 
-
-这是在这儿应为中文常常没有英文程序词语。
-
-English 是在 JME 英文用的词。中文是 JME 中文用的词。意思是中文意思。
-[cols="3", options="header"]
-|===
-
-a|English
-a|中文
-a|意思
-
-a|Node
-a|Node
-a|
-
-|===

src/docs/asciidoc/jme3/beginner/hello_asset_pt.adoc

@@ -1,422 +0,0 @@
-= jMonkeyEngine 3 Tutorial (3) - Hello Assets
-:author:
-:revnumber:
-:revdate: 2016/03/17 20:48
-:keywords: beginner, intro, documentation, lightnode, material, model, node, gui, hud, texture
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Anterior: <<jme3/beginner/hello_node_pt#, Hello Node pt>>,
-Próximo: <<jme3/beginner/hello_main_event_loop_pt#, Hello Update Loop pt>>
-
-Neste tutorial nós aprenderemos a carregar modelos 3D e colcoar texto no grafo de cena, usando o <<jme3/advanced/asset_manager#, Gerenciador de Ativo (Asset Manager)>> da JME. Você também aprenderá como determinar os caminhos corretos, e quais formatos de arquivo usar.
-
-
-image::jme3/beginner/beginner-assets-models.png[beginner-assets-models.png,width="320",height="250",align="center"]
-
-
-
-[TIP]
-====
-<<sdk/sample_code#, Problema no achar os arquivos para executar a amostra?>> Para conseguir os ativos (modelos 3D), adicione o arquivo `jme3-test-data.jar` incluso para seu classpath. no projeto criado com o SDK da jMonkeyEngine (recomendado), simplesmente dê um clique com o botão direito em seu projeto, escolha “Propriedades (“Properties), vá para “Bibliotecas (“Libraries), pressione “Adicionar Biblioteca (“Add Library) e adiciona a biblioteca pré-configurada “jme3-test-data library.
-====
-
-
-
-== Amostra de Código
-
-[source,java]
-----
-
-package jme3test.helloworld;
-
-import com.jme3.app.SimpleApplication;
-import com.jme3.font.BitmapText;
-import com.jme3.light.DirectionalLight;
-import com.jme3.material.Material;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.Spatial;
-import com.jme3.scene.shape.Box;
-
-/** Sample 3 - how to load an OBJ model, and OgreXML model,
- * a material/texture, or text. */
-public class HelloAssets extends SimpleApplication {
-
-    public static void main(String[] args) {
-        HelloAssets app = new HelloAssets();
-        app.start();
-    }
-
-    @Override
-    public void simpleInitApp() {
-
-        Spatial teapot = assetManager.loadModel("Models/Teapot/Teapot.obj");
-        Material mat_default = new Material(
-            assetManager, "Common/MatDefs/Misc/ShowNormals.j3md");
-        teapot.setMaterial(mat_default);
-        rootNode.attachChild(teapot);
-
-        // Create a wall with a simple texture from test_data
-        Box box = new Box(Vector3f.ZERO, 2.5f,2.5f,1.0f);
-        Spatial wall = new Geometry("Box", box );
-        Material mat_brick = new Material(
-            assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat_brick.setTexture("ColorMap",
-            assetManager.loadTexture("Textures/Terrain/BrickWall/BrickWall.jpg"));
-        wall.setMaterial(mat_brick);
-        wall.setLocalTranslation(2.0f,-2.5f,0.0f);
-        rootNode.attachChild(wall);
-
-        // Display a line of text with a default font
-        guiNode.detachAllChildren();
-        guiFont = assetManager.loadFont("Interface/Fonts/Default.fnt");
-        BitmapText helloText = new BitmapText(guiFont, false);
-        helloText.setSize(guiFont.getCharSet().getRenderedSize());
-        helloText.setText("Hello World");
-        helloText.setLocalTranslation(300, helloText.getLineHeight(), 0);
-        guiNode.attachChild(helloText);
-
-        // Load a model from test_data (OgreXML + material + texture)
-        Spatial ninja = assetManager.loadModel("Models/Ninja/Ninja.mesh.xml");
-        ninja.scale(0.05f, 0.05f, 0.05f);
-        ninja.rotate(0.0f, -3.0f, 0.0f);
-        ninja.setLocalTranslation(0.0f, -5.0f, -2.0f);
-        rootNode.attachChild(ninja);
-        // You must add a light to make the model visible
-        DirectionalLight sun = new DirectionalLight();
-        sun.setDirection(new Vector3f(-0.1f, -0.7f, -1.0f));
-        rootNode.addLight(sun);
-
-    }
-}
-----
-
-Compile e execute a amostra de código. Você deveria ver um ninja verde com um bule colorido permanecendo atrás de uma parede. O texto na tela deveria dizer “Hello World.
-
-
-== O gerenciador de ativo
-
-*Por ativos de jogo nós queremos dizer todos os arquivos multimídia, tais como modelos, materiais e texturas, cenas inteiras, shaders customizados, música e arquivos de som, e fontes customizadas.* JME3 vem com um objeto AssetManager prático que ajuda você a acessar seus ativos.
-O AssetManager pode carregar arquivos de:
-
-*  O classpath atual (o nível do topo de seu diretório de projeto),
-*  O diretório `ativos` de seu projeto, e
-*  opcionalmente, caminhos persoanlizados que você registrar.
-
-O seguinte é a estrutura de diretório recomendada em seu diretório de projeto:
-
-[source]
-----
-
-MyGame/assets/Interface/
-MyGame/assets/MatDefs/
-MyGame/assets/Materials/
-MyGame/assets/Models/
-MyGame/assets/Scenes/
-MyGame/assets/Shaders/
-MyGame/assets/Sounds/
-MyGame/assets/Textures/
-MyGame/build.xml            <-- Ant build script
-MyGame/src/...              <-- Java sources go here
-MyGame/...
-
-----
-
-Isto é apenas um melhor prática sugerida, e é o que você consegue por padrão quando criando um novo projeto Java no <<jme3/beginner/sdk#,SDK>> da jMokeyEngine. Você pode criar um diretório de ativos e tecnicamente nomear os subdiretórios da maneira que você gostar.
-
-
-=== Carregando Texturas
-
-Coloque suas texturas em um subdiretório de `assets/Textures/`. Carregue a textura em um material antes que você configure o Material. A seguinte amostra de código é do método `simpleInitApp()` e carrega um modelo de parede simples:
-
-[source,java]
-----
-
-// Create a wall with a simple texture from test_data
-Box box = new Box(Vector3f.ZERO, 2.5f,2.5f,1.0f);
-Spatial wall = new Geometry("Box", box );
-Material mat_brick = new Material(
-    assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-mat_brick.setTexture("ColorMap",
-    assetManager.loadTexture("Textures/Terrain/BrickWall/BrickWall.jpg"));
-wall.setMaterial(mat_brick);
-wall.setLocalTranslation(2.0f,-2.5f,0.0f);
-rootNode.attachChild(wall);
-
-----
-
-Neste caso, você <<jme3/beginner/hello_material#,cria seu próprio Material>> e aplica ele para a geometria (Geometry). Você baseia Materiais nas descrições de material padrão (por exemplo, “Unshaded.j3md), como mostrado neste exemplo.
-
-
-=== Carregando Texto e Fontes
-
-Este exemplo exibe o texto “Hello World na fonte padrão na aresta do fundo da janela. Você anexa texto para o nó da +++<abbr title="Graphical User Interface">GUI</abbr>+++ (`guiNode`) – isto é um nó especial para elementos de exibição plana (ortogonal). Você exibe texto para mostrar a pontuação do jogo, a saúde do jogador, etc.
-A seguinte amostra de código vai no método `simpleInitApp()`.
-
-[source,java]
-----
-// Display a line of text with a default font
-guiNode.detachAllChildren();
-guiFont = assetManager.loadFont("Interface/Fonts/Default.fnt");
-BitmapText helloText = new BitmapText(guiFont, false);
-helloText.setSize(guiFont.getCharSet().getRenderedSize());
-helloText.setText("Hello World");
-helloText.setLocalTranslation(300, helloText.getLineHeight(), 0);
-guiNode.attachChild(helloText);
-
-----
-
-*Dica:* Limpe o texto existente no nó da +++<abbr title="Graphical User Interface">GUI</abbr>+++ (guiNode) por retirar todas as suas crianças.
-
-
-=== Carregando um modelo
-
-Exporte seu modelo 3D no formato OgreXML (.mesh.xml, .scene, .material, .skeleton.xml) e coloque ele em um subdiretório de `assets/Models/`. A seguinte amostra de código vai no método `simpleInitApp()`.
-
-[source,java]
-----
-
-// Load a model from test_data (OgreXML + material + texture)
-Spatial ninja = assetManager.loadModel("Models/Ninja/Ninja.mesh.xml");
-ninja.scale(0.05f, 0.05f, 0.05f);
-ninja.rotate(0.0f, -3.0f, 0.0f);
-ninja.setLocalTranslation(0.0f, -5.0f, -2.0f);
-rootNode.attachChild(ninja);
-// You must add a directional light to make the model visible!
-DirectionalLight sun = new DirectionalLight();
-sun.setDirection(new Vector3f(-0.1f, -0.7f, -1.0f).normalizeLocal());
-rootNode.addLight(sun);
-
-----
-
-Note que você precisa criar um Material se você exportou o modelo com um material. Lembre-se de adicionar uma fonte de luz, como mostrado, de outra maneira o material (e o modelo inteiro) não estará visível!
-
-
-=== Carregando Ativos de Caminhos Personalizados
-
-E seu jogo dependen de arquivos de modelo fornecidos pelo usuário, que não estão inclusos na distribuição? Se um arquivo não é localizado no local padrão (e.g. diretório de ativos), você pode registrar um localizador (Locator) customizado e carregá-lo de qualquer caminho.
-
-Aqui está um exemplo de uso de um ZipLocator que está registrado para um arquivo `town.zip` no nível topo de seu diretório de projeto:
-
-[source,java]
-----
-
-    assetManager.registerLocator("town.zip", ZipLocator.class);
-    Spatial scene = assetManager.loadModel("main.scene");
-    rootNode.attachChild(scene);
-
-----
-
- Aque está um HttpZipLocator que pode baixar modelos zipados e carregá-los:
-
-[source,java]
-----
-
-    assetManager.registerLocator(
-      "http://jmonkeyengine.googlecode.com/files/wildhouse.zip",
-      HttpZipLocator.class);
-    Spatial scene = assetManager.loadModel("main.scene");
-    rootNode.attachChild(scene);
-
-----
-
-JME3 oferece ClasspathLocator, ZipLocator, FileLocator, HttpZipLocator, e UrlLocator (Veja `com.jme3.asset.plugins`).
-
-
-== Criando Modelos e Cenas
-
-Para criar modelos 3D e cenas, você precisa de um editor de malha 3D (3D Mesh Editor) com um plugin exportador (Exporter) OgreXML. Por exemplo, você pode link:http://en.wikibooks.org/wiki/Blender_3D:_Noob_to_Pro/UV_Map_Basics[ criar modelos completamente texturizados com Blender].
-
-Você pode usar o <<sdk#,SDK>> para <<sdk/model_loader_and_viewer#,carregar modelos>>, <<sdk/blender#, converter modelos>> e <<sdk/scene_composer#, criar cenas>> deles.
-
-Se você usar Blender, exporte seus modelos como malhas Ogre XML com materiais como se segue:
-
-.  Abra o menu Arquivo (File) &gt; Exportar (Export) &gt; Exportador OgreXML (OgreXML Exporter) para abrir o diálogo do exportador.
-.  No campo Exportar Materiais (Export Materials): Dê ao material o mesmo nome que o modelo. Por exemplo, o modelo `something.mesh.xml` acompanha `something.material`, mais (opcionalmente) `something.skeleton.xml` e alguns arquivos de textura JPG.
-.  No campo Exportar Malhas (Export Meshes): Selecione um subdiretório de seu diretório `assets/Models/` directory. E.g. `assets/Models/something/`.
-.  Ative as seguintes configurações do exportador:
-**  Copiar Texturas (Copy Textures): YES
-**  Renderizar materiais (Rendering Materials): YES
-**  Virar Eixos (Flip Axis): YES
-**  Requer Materiais (Require Materials): YES
-**  Nome do Esqueleto segue o da malha (Skeleton name follows mesh): YES
-
-.  Clique em exportar.
-
-
-=== Formatos de Arquivo de Modelo
-
-JME3 pode carregar modelos Ogre XML + materials, Ogre DotScenes, bem como modelos Wavefront OBJ+MTL models. O código loadModel() trabalha com estes arquivos quando você executa o código diretamente do SDK da jMonkeyEngine SDK.
-
-Se você construir os executáveis usando o scrit de construção padrão, então os arquivos de modelo originais (XML, OBJ, etc) não são inclusos. Quando você executar o executável, você obetrá uma mensagem de erro se você tentar carregar quaisquer modelos diretamente:
-
-[source]
-----
-com.jme3.asset.DesktopAssetManager loadAsset
-WARNING: Cannot locate resource: Models/Ninja/Ninja.mesh.xml
-com.jme3.app.Application handleError
-SEVERE: Uncaught exception thrown in Thread[LWJGL Renderer Thread,5,main]
-java.lang.NullPointerException
-
-----
-
-Carregando os arquivos XML/OBJ diretamente é somente aceitável durante a fase de desenvolvimento. Se seus projetista gráfico coloca arquivos atualizados para o diretório de ativos, você pode rapidamente revisar a versão mais recente em seu ambiente de desenvolvimento.
-
-Para teste e para a construção de liberação final, voc~e usa arquivos .j3o exclusivamente. J3o é um formato binário otimizado para aplicações jME3, e arquivos .j3o são automaticamente inclusos no arquivo JAR distribuível pelo script de construção. Quando você faz construções de teste de QA (Quality and Assurance - Averiguação da Qualidade) ou está pronto para liberar, use o <<sdk#,SDK>> para <<sdk/model_loader_and_viewer#, converter>> todos os arquivos .obj/.scene/.xml/.blend para .j3o, e somente carregue as versões .j3o.
-
-Abra seu Projeto JME3 no SDK da jMonkeyEngine.
-
-.  Dê um clique com o botão direito em um arquivo .Blend, .OBJ, ou .mesh.xml file na janela Projetos (Projects), e escolha “converter para binário JME3 (“convert to JME3 binary)..
-.  O arquivo .j3o aparece próximo ao arquivo .mesh.xml file e tem o mesmo nome.
-.  Mude todas as linhas do seu loadModel() de acordo. Por exemplo:
-[source,java]
-----
-Spatial ninja = assetManager.loadModel("Models/Ninja/Ninja.j3o");
-----
-
-
-Se seu executável dá uma exceção em tempo de execução, tenha certeza de que você converteu todos os modelos para .j3o!
-
-
-=== Carregando Modelos e a Cena
-[cols="2", options="header"]
-|===
-
-a| tarefa?
-a| Solução!
-
-a| Carregar um modelo com materiais
-a| Use o método `loadModel()` do gerenciador de ativo (asset manager) e anexe o Spatial para o nó raiz (rootNode).
-[source,java]
-----
-Spatial elephant = assetManager.loadModel("Models/Elephant/Elephant.mesh.xml");
-rootNode.attachChild(elephant);
-----
-
-[source,java]
-----
-Spatial elephant = assetManager.loadModel("Models/Elephant/Elephant.j3o");
-rootNode.attachChild(elephant);
-----
-
-
-a| carregar um modelo sem materiais
-a| Se você tiver um modelo sem materiais, você tem de dár a ele um material para fazê-lo visível.
-[source,java]
-----
-Spatial teapot = assetManager.loadModel("Models/Teapot/Teapot.j3o");
-Material mat = new Material(assetManager, "Common/MatDefs/Misc/ShowNormals.j3md"); // default material
-teapot.setMaterial(mat);
-rootNode.attachChild(teapot);
-----
-
-
-a| Carregar uma cena
-a| Você carrega cenas da mesma forma que você carrega modelos:
-[source,java]
-----
-Spatial scene = assetManager.loadModel("Scenes/town/main.scene");
-rootNode.attachChild(scene);
-----
-
-[source,java]
-----
-Spatial scene = assetManager.loadModel("Scenes/town/main.j3o");
-rootNode.attachChild(scene);
-----
-
-
-|===
-
-
-== Exercício - Como Carregar Ativos
-
-Como um exercício, vamos tentar diferentes maneiras de carregar uma cena. Você aprenderá a como carregar a cena diretamente, ou de um arquivo zip.
-
-.  link:http://jmonkeyengine.googlecode.com/svn/trunk/engine/town.zip[baixe a cena de amostra town.zip].
-.  (Opcional:) Dezipe o arquivo town.zip para ver a estrutura da Ogre dotScene contida: Você terá um diretório chamado `town`. Ele contém arquivos XML e textura, e o arquivo chamado main.scene. (Isto é apenas para sua informação, você não precisa fazer nada com ele.)
-.  Coloque o arquivo town.zip no diretório topo de nível de seu projeto JME3, assim:
-[source]
-----
-jMonkeyProjects/MyGameProject/assets/
-jMonkeyProjects/MyGameProject/build.xml
-jMonkeyProjects/MyGameProject/src/
-jMonkeyProjects/MyGameProject/town.zip
-...
-
-----
-
-
-Use o seguinte método para carregar modelos de um arquivo zip:
-
-.  Verifique se `town.zip` está no diretório do projeto.
-.  Registre um localizador de arquivo zip para o diretório do projeto: Adicione o seguinte código sobre `simpleInitApp(){`
-[source,java]
-----
-    assetManager.registerLocator("town.zip", ZipLocator.class);
-    Spatial gameLevel = assetManager.loadModel("main.scene");
-    gameLevel.setLocalTranslation(0, -5.2f, 0);
-    gameLevel.setLocalScale(2);
-    rootNode.attachChild(gameLevel);
-----
-
-O método loadModel() agora pesquisa pelo arquivo zip diretamente para carregar os arquivos (isto significa, não escreva `loadModel(town.zip/main.scene)` ou similar!)
-
-.  Limpe, construa e execute o projeto. +Você deveria agora ver o Ninja+parede+bule permanecendo em uma cidade.
-
-*Dica:*  se você registrar novos localizadores, tenha certeza de que você não tenha quaisquer conflitos de nome: Não nomeie todas as cenas `main.scene` mas dê a cada cena um nome único.
-
-Anteriormente neste tutorial, você carregou cenas e modelos do diretório de ativo. Isto é a maneira mais comum que você estará carregando cenas e modelos. Aqui está o procedimento típico:
-
-.  Remova o código que você adicionou para o exercício anterior.
-.  Mova o diretório dezipado `town/` no diretório `assets/Scenes/` de seu projeto.
-.  Adicione o seguinte código sobre `simpleInitApp() {`
-[source,java]
-----
-    Spatial gameLevel = assetManager.loadModel("Scenes/town/main.scene");
-    gameLevel.setLocalTranslation(0, -5.2f, 0);
-    gameLevel.setLocalScale(2);
-    rootNode.attachChild(gameLevel);
-----
-
- Note que o caminho é relativo ao diretório `assets/…`.
-
-.  Limpe, construa e execute o projeto. De novo, você deveria ver o Ninja+parede+bule em uma cidade.
-
-Aqui está um terceiro método que você deve conhecer, carregando uma cena/modelo de um arquivo .j3o:
-
-.  Remova o código do exercício anterior.
-.  Se você j´pa não fez, abra o <<sdk#,SDK>> e abra o projeto que contém a classe HelloAsset..
-.  Na janela de projetos, navegue para o diretório `assets/Scenes/town`.
-.  Dê um clique com o botão direito em `main.scene` e converta a cena para binário: A jMonkeyPlatform gera um arquivo main.j3o.
-.  Adicione o seguinte código em `simpleInitApp() {`
-[source,java]
-----
-    Spatial gameLevel = assetManager.loadModel("Scenes/town/main.j3o");
-    gameLevel.setLocalTranslation(0, -5.2f, 0);
-    gameLevel.setLocalScale(2);
-    rootNode.attachChild(gameLevel);
-----
-
- Novamente, note que o caminho é relativo ao diretório `assets/…` directory.
-
-.  Limpe, construa e execute o projeto. +De novo, você deveria ver o Ninja+parede+bule em uma cidade.
-
-
-== Conclusão
-
-Agora você sabe como popular o grafo de cena com modelos e formas estáticas, e como construir cenas. Você aprendeu como carregar ativos usando o `gerenciador de ativos (assetManager)` e você viu que os caminhos iniciam relativos ao seu diretório de projeto. Uma outra coisa importante que você aprendeu é converter modelos para o formato .j3o para os JARs executáveis etc.
-
-Vamos adicionar alguma ação para a cena e continuar com o  <<jme3/beginner/hello_main_event_loop-pt#, Loop de Atualização pt>>!
-'''
-
-*See also:*
-
-*  <<jme3/external/blender#,O tutorial de importação Blender definitivo>>
-*  link:http://www.jmonkeyengine.com/forum/index.php?topic=14418.0[Instantâneos de um grande modelo carregado]
-*  link:http://www.youtube.com/user/aramakara[Video tutoriais for obter OgreXML do 3DS Max usando OgreMax]
-*  Se você quer aprender a como carregar sons, veja <<jme3/beginner/hello_audio_pt#,Hello Audio pt>>
-*  Se você quer aprender mais sobre carregar materiais, veja <<jme3/beginner/hello_material_pt#,Hello Material pt>>

src/docs/asciidoc/jme3/beginner/hello_main_event_loop_pt.adoc

@@ -1,146 +0,0 @@
-= jMonkeyEngine 3 Tutorial (4) - Hello Update Loop
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:keywords: documentation, state, states, intro, beginner, control, loop
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Anterior: <<jme3/beginner/hello_asset-pt#, Hello Assets pt>>,
-Next: <<jme3/beginner/hello_input_system-pt#, Hello Input System pt>>
-
-Agora que você sabe como carregar ativos, como modelos 3D, você quer implementar alguma jogabilidade que usa estes ativos. Neste tutorial nós olhamos no loop de atualização. O loop de atualização de seu jogo é onde a ação acontece.
-
-
-== Amostra de Código
-
-[source,java]
-----
-
-package jme3test.helloworld;
-
-import com.jme3.app.SimpleApplication;
-import com.jme3.material.Material;
-import com.jme3.math.ColorRGBA;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.shape.Box;
-
-/** Sample 4 - how to trigger repeating actions from the main update loop.
- * In this example, we make the player character rotate. */
-public class HelloLoop extends SimpleApplication {
-
-    public static void main(String[] args){
-        HelloLoop app = new HelloLoop();
-        app.start();
-    }
-
-    protected Geometry player;
-
-    @Override
-    public void simpleInitApp() {
-
-        Box b = new Box(Vector3f.ZERO, 1, 1, 1);
-        player = new Geometry("blue cube", b);
-        Material mat = new Material(assetManager,
-          "Common/MatDefs/Misc/Unshaded.j3md");
-        mat.setColor("Color", ColorRGBA.Blue);
-        player.setMaterial(mat);
-        rootNode.attachChild(player);
-    }
-
-    /* This is the update loop */
-    @Override
-    public void simpleUpdate(float tpf) {
-        // make the player rotate
-        player.rotate(0, 2*tpf, 0); 
-    }
-}
-----
-
-Compile e execute o arquivo: Você vê um cubo rotacionando constantemente.
-
-
-== Entendendo o Código
-
-Comparado a nossos exemplos de código anteriores você nota que a geometria (Geometry) do jogador é agora um campo (atributo) de classe. Isto é porque nós queremos que o loop de atualização seja capaz de acessar e transformar esta geometria (Geometry). Como notmal, nós inicializamos o objeto jogador no método `simpleInitApp()`.
-
-Agora dê uma olhada mais de perto no método `simpleUpdate()` – este é o loop de atualização.
-
-*  A linha `player.rotate(0, 2*tpf, 0);` muda a rotação do objeto jogador.
-*  Nós usamos a variável `tpf` (tempo por quadro) (“time per frame) para temporizar esta ação dependendo da taxa atual de quadros por segundo. Isto simplesmente significa que o cubo rotaciona com a mesma velocidade em máquinas rápidas e lentas, e o jogo permanece jogável.
-*  Quando o jogo executa, o código rotate() é executado repetidamente.
-
-
-== Usando o Loop de Atualização
-
-Um objeto rotacionando é apenas um exemplo simples. No loop de atualização, você tipicamente tem muitos testes e dispara várias ações de jogo. Isto é onde você atualiza a pontuação e pontos de vida, checa por colisões, faz os inimigos calcularem o próximo movimento deles, rola os dados se uma armadilha foi colocada, toca sons ambiente aleatórios, e muito mais.
-
-*  O método `simpleUpdate()` inicia sua execução após o método `simpleInitApp()` ter inicializado o grafo de cena e as variáveis de estado.
-*  JME3 executa tudo no método simpleUpdate() repetidamente, tão rápido quanto possível.
-..  Use o loop para consultar o estado do jogo e então inciar ações.
-..  Use o loop para disparar reações e atualizar o estado do jogo.
-..  Use o loop com sabedoria, por que ter chamadas demais no loop também faz o jogo mais executar mais lento.
-
-
-
-== Inicializar - Atualizar - Renderizar
-
-Note o contraste:
-
-*  O método `simpleInitApp()` é executado somente uma vez, imediatamente no início;
-*  O método `simpleUpdate()` executa repetidamente, durante o jogo.
-*  Depois de toda atualização a jMonkeyEngine automaticamente redesenha (renderiza) a tela para você!
-
-Desde que rendering é automático e, inicialização e a atualiação são os dois conceitos mais importantes em uma SimpleApplication para você imediatamente. Estes métodos são onde você carrega e cria dados do jogo (uma vez), e (repetidamente) muda as propriedades deles para atualizar o estado do jogo:
-
-*  `simpleInitApp()` é a “primeira respiração da aplicação.
-*  `simpleUpdate()` é a batida de coração da aplicação. +A unidade de tempo de atualização é chamada `tiques (ticks)`.
-
-
-[TIP]
-====
-Tudo em um jogo acontece ou durante a inicialização ou durante o loop de atualização. Isto significa que estes dois métodos crescem muito com o tempo. Há duas estratégias como desenvolvedores experientes espalham o código de atualização e inicialização em várias classes Java:
-
-*  Mova os blocos de código do método simpleInitApp() para <<jme3/advanced/application_states#, AppStates>>.
-*  Mova os blocos de código do método simpleUpdate() para <<jme3/advanced/custom_controls#,Custom Controls>>.
-
-mantenha isto em mente pata depois quando sua aplicação crescer.
-
-====
-
-
-
-== Exercícios
-
-Aqui estão algumas coisas divertidas para experimentar:
-
-.  O que acontece se você dar ao método rotate() números negativos?
-.  Você pode criar duas geometrias (Geometries) uma próxima a outra, e fazer uma rotacionar duas vezes mais rápido que a outra? (use a varuável `tpf`)
-.  Você pode fazer um cubo que pulsa (cresce e diminui)
-.  Você pode fazer um cubo que muda de cor? (mude e configure o Material)
-.  Você pode fazer um cubo que role (rotacione ao redor do eixo x, e translade ao longo do eixo z)
-
-Olhe de volta no tutorial <<jme3/beginner/hello_node#,Hello Node>> se você não lembra os métodos de transformação para escalonar, transladar, e rotacionar.
-
-
-[IMPORTANT]
-====
-Link para soluções propostas pelos usuário: <<jme3/beginner/solutions#,jme3:solutions>>
-+++<u> Esteja certo de tentar resolvê-las por si só primeiro!</u>+++
-====
-
-
-
-== Conclusão
-
-Agora você está ouvindo ao loop de atualização, “a batida do coração do jogo, e você pode adicionar todos os tipos de ação a ele.
-
-A próxima coisa que o jogo precisa é alguma interação! Continue aprendendo a como <<jme3/beginner/hello_input_system-pt#, responder a entrada do usuário pt>>.
-'''
-
-Veja também:
-
-*  Desenvolvedores jME3 avançados usam <<jme3/advanced/application_states#, Estados da Aplicação (Application States)>> e <<jme3/advanced/custom_controls#, Controles Personalizados (Custom Controls)>> para implementar mecânicas de jogo no loop de atualização deles. Você topará nestes tópicos de novo mais tarde quando você proceder para documentação mais avançada.

src/docs/asciidoc/jme3/beginner/hello_node_pl.adoc

@@ -1,334 +0,0 @@
-= JME 3 Tutorial (2) - Hello Node
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:keywords: beginner, rootNode, node, intro, documentation, color, polish
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Poprzedni: <<jme3/beginner/hello_simpleapplication_pl#,Hello SimpleApplication>>,
-Następny: <<jme3/beginner/hello_asset#,Hello Assets>>. ++
-Kiedy tworzysz grę, zaczynasz od stworzenia sceny oraz paru obiektów. Umieszczasz obiekty na scenie, a następnie przemieszczasz, obracasz, zmniejszasz oraz animujesz je. ++
-W tym tutorialu rzucimy okiem na prostą scenę trójwymiarową.  3D world is represented in a scene graph, i dlaczego rootNode jest tak ważny. Dowiesz się jak tworzyć i manipulować obiektami – przemieszczać, skalować czy obracać. Zrozumiesz różnicę pomiędzy dwoma typami Spatials w scene graph, Node i Geometry. Aby zrozumieć jak działa scene graph zajrzyj do prezentacji introduction to the scene graph check out our <<jme3/scenegraph_for_dummies#, Scene Graph for Dummies>>.
-
-
-== Kod źródłowy
-
-[source,java]
-----
-
-package jme3test.helloworld;
-import com.jme3.app.SimpleApplication;
-import com.jme3.material.Material;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.shape.Box;
-import com.jme3.math.ColorRGBA;
-import com.jme3.scene.Node;
-/** Przykład 2 - How to use nodes as handles to manipulate objects in the scene graph.
- * You can rotate, translate, and scale objects by manipulating their parent nodes.
- * The Root Node is special: Only what is attached to the Root Node appears in the scene. */
-public class HelloNode extends SimpleApplication {
-    public static void main(String[] args){
-        HelloNode app = new HelloNode();
-        app.start();
-    }
-    @Override
-    public void simpleInitApp() {
-        // create a blue box at coordinates (1,-1,1)
-        Box box1 = new Box( new Vector3f(1,-1,1), 1,1,1);
-        Geometry blue = new Geometry("Box", box1);
-        Material mat1 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat1.setColor("Color", ColorRGBA.Blue);
-        blue.setMaterial(mat1);
-        // create a red box straight above the blue one at (1,3,1)
-        Box box2 = new Box( new Vector3f(1,3,1), 1,1,1);
-        Geometry red = new Geometry("Box", box2);
-        Material mat2 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat2.setColor("Color", ColorRGBA.Red);
-        red.setMaterial(mat2);
-        // create a pivot node at (0,0,0) and attach it to root
-        Node pivot = new Node("pivot");
-        rootNode.attachChild(pivot);
-        // attach the two boxes to the *pivot* node!
-        pivot.attachChild(blue);
-        pivot.attachChild(red);
-        // rotate pivot node: Both boxes have rotated!
-        pivot.rotate( 0.4f , 0.4f , 0.0f );
-    }
-}
-----
-
-Build and run the code sample. You should see two colored boxes tilted at the same angle.
-
-
-== Understanding the Terminology
-
-In this tutorial, you will learn some new terms:
-
-.  The _scene graph_ represents your 3D world.
-.  Objects in the scene graph (such as the boxes in this example) are called _Spatials_.
-**  A Spatial is a collection of information about an object: its location, rotation, and scale.
-**  A Spatial can be loaded, transformed, and saved.
-
-.  There are two types of Spatials, _Nodes_ and _Geometries_.
-.  To add a Spatial to the scene graph, you attach the Spatial to the _rootNode_.
-.  Everything attached to the _rootNode_ is part of the scene graph.
-
-
-== Understanding the Code
-
-So what exactly happens in this code snippet? Note that we are using the `simpleInitApp()` method that was introduced in the first tutorial.
-
-.  We create a box Geometry.
-**  The box Geometry's extends are (1,1,1), that makes it 2x2x2 world units big.
-**  We place the box at (1,-1,1)
-**  We give it a solid blue material. 
-[source,java]
-----
-
-        Box box1 = new Box( new Vector3f(1,-1,1), 1,1,1);
-        Geometry blue = new Geometry("Box", box1);
-        Material mat1 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat1.setColor("Color", ColorRGBA.Blue);
-        blue.setMaterial(mat1);
-----
-
-
-.  We create a second box Geometry.
-**  This box Geometry is also 2x2x2 world units big.
-**  We place the second box at (1,3,1). This is straight above the blue box, with a gap of 2 world units inbetween.
-**  We give it a solid red material
-[source,java]
-----
-
-        Box box2 = new Box( new Vector3f(1,3,1), 1,1,1);
-        Geometry red = new Geometry("Box", box2);
-        Material mat2 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat2.setColor("Color", ColorRGBA.Red);
-        red.setMaterial(mat2);
-----
-
-
-.  We create a Node.
-**  By default the Node is placed at (0,0,0).
-**  We attach the Node to the rootNode.
-**  An attached Node has no visible appearance in the scene. 
-[source,java]
-----
-
-        Node pivot = new Node("pivot");
-        rootNode.attachChild(pivot);
-----
-
-
-.  Note that we have not attached the two boxes to anything yet!
-**  _If we ran the application now, the scenegraph would appear empty._
-
-.  We attach the two boxes to the node.
-**  _If we ran the app now, we would see two boxes: one straight above the other._ 
-[source,java]
-----
-
-        pivot.attachChild(blue);
-        pivot.attachChild(red); 
-----
-
-
-.  Now, we rotate the node.
-**  _When we run the application now, we see two boxes on top of each other – but both are tilted at the same angle._ 
-[source,java]
-----
-
-        pivot.rotate( 0.4f , 0.4f , 0.0f );
-----
-
-
-
-What has happened? We have attached two box Geometries to a Node. Then we used the Node as a handle to grab the two boxes and transform (rotate) both, in one step. This is a common task and you will use this method a lot in your games when you move game characters around.
-
-
-=== Definition: Geometry vs Node
-
-You work with two types of Spatials in your scenegraph: Nodes and Geometries. Here is the difference:
-[cols="3", options="header"]
-|===
-
-<a|  
-a| Geometry 
-a| Node 
-
-a| Visibility: 
-a| A visible 3-D object. 
-a| An invisible “handle. 
-
-a| Purpose: 
-a| A Geometry stores an object's looks. 
-a| A Node groups Geometries and other Nodes together. 
-
-a| Examples: 
-a| A box, a sphere, player, a building, a piece of terrain, a vehicle, missiles, NPCs, etc… 
-a| The default `rootNode`, the `guiNode` (for on-screen text); a floor node, a custom vehicle-with-passengers node, an audio node, etc… 
-
-|===
-
-
-== FAQ: How to Populate the Scenegraph?
-[cols="2", options="header"]
-|===
-
-a| Task? 
-a| Solution! 
-
-a| Create a Spatial 
-a| Create a shape and give it a Material. For instance a box shape: 
-[source,java]
-----
-Box mesh = new Box(Vector3f.ZERO, 1, 1, 1);
-Geometry thing = new Geometry("thing", mesh);
-Material mat = new Material(assetManager, "Common/MatDefs/Misc/ShowNormals.j3md");
-thing.setMaterial(mat);
-----
-
-
-a| Make an object appear in the scene 
-a| Attach the Spatial to the `rootNode`, or to any node that is attached to the rootNode. 
-[source,java]
-----
-rootNode.attachChild(thing);
-----
-
-
-a| Remove objects from the scene 
-a| Detach the Spatial from the `rootNode`, and from any node that is attached to the rootNode. 
-[source,java]
-----
-rootNode.detachChild(thing);
-----
-
-[source,java]
-----
-rootNode.detachAllChildren();
-----
-
-
-a| Find a Spatial in the scene by the object's name or ID 
-a| Look at the node's children. 
-[source,java]
-----
-Spatial thing = rootNode.getChild("thing");
-----
-
-[source,java]
-----
-Spatial twentyThird = rootNode.getChild(22);
-----
-
-
-a| Specify what should be loaded at the start 
-a| Everything you initialize and attach to the `rootNode` in the `simpleInitApp()` method is part of the scene at the start of the game. 
-
-|===
-
-
-== How to Transform Objects?
-
-There are three types of 3D transformation: Translation (moving), Scaling (resizing), and Rotation (turning).
-[cols="5", options="header"]
-|===
-
-a| Task? 
-a| Solution! 
-a| X 
-a| Y 
-a| Z 
-
-a| Position and move objects 
-a| *Translation:* Specify the new location in three dimensions: right/left, up/down, forward/backward. +Example 1. To move an object _to_ specific coordinates, such as (0,40.2f,-2), use: 
-[source,java]
-----
-thing.setLocalTranslation( new Vector3f( 0.0f, 40.2f, -2.0f ) );
-----
-
- +Example 2: To move an object _by_ a certain amount, e.g. higher up (y=40.2f) and further back (z=-2.0f): 
-
-[source,java]
-----
-thing.move( 0.0f, 40.2f, -2.0f );
-----
-
-a|right/left
-a|up/down
-a|forward/ backward
-
-a| Resize objects 
-a| *Scaling:* To resize a Spatial, specify the scale factor in each dimension: length, height, width. A value between 0.0f and 1.0f will shrink the object; a value bigger than 1.0f will make it grow; and 1.0f will keep this dimension the same. Using the same value for each dimension scales an object proportionally, using different values stretches it. +Example: Make it 10 times longer, one tenth of the height, same width: 
-[source,java]
-----
-thing.setLocalScale( 10.0f, 0.1f, 1.0f  );
-----
-
-[source,java]
-----
-thing.scale( 10.0f, 0.1f, 1.0f );
-----
-
-a|length
-a|height
-a|width
-
-a| Turn objects 
-a| *Rotation:* 3-D rotation is a bit tricky (<<jme2/rotate#,learn details here>>). In short: You can rotate around three axes, pitch, yaw, and roll. +Important: *You do not specify the rotation in degrees from 0° to 360°, but in radians from 0.0f to 6.28f (FastMath.PI*2) !* +Example: To roll an object 180° around the z axis: 
-[source,java]
-----
-thing.rotate( 0f , 0f , FastMath.PI );
-----
-
- If you do want to specify angles in degrees then multiply your degrees value with FastMath.DEG_TO_RAD +Example: 
-
-[source,java]
-----
-thing.rotate( 0f , 0f , 180*FastMath.DEG_TO_RAD );
-----
-
-  Tip: If your game idea calls for a serious amount of rotations, it is worth looking into <<jme2/quaternion#,quaternion>>s, a data structure that can combine and store rotations efficiently. 
-
-[source,java]
-----
-thing.setLocalRotation( new Quaternion(). fromAngleAxis(FastMath.PI/2, new Vector3f(1,0,0)));
-----
-
-a|pitch
-a|yaw
-a|roll
-
-|===
-
-
-== How to Troubleshoot Nodes?
-
-If you get unexpected results, check whether you made the following common mistakes:
-[cols="2", options="header"]
-|===
-
-a| Problem? 
-a| Solution! 
-
-a| Created Geometry does not appear in scene 
-a| Have you attached it to (a node that is attached to) the rootNode? +Does it have a Material? +What is its translation (position)? Is it covered up by another Geometry? +Is it too far from the camera? try link:http://jmonkeyengine.org/javadoc/com/jme3/renderer/Camera.html#setFrustumFar%28float%29[cam.setFrustumFar](111111f); 
-
-a| Spatial rotates wrong 
-a| Did you use radian values, and not degrees? (if you used degrees multiply them with FastMath.DEG_TO_RAD to get them converted to radians)+Did you rotate the intended pivot node? +Did you rotate around the right axis? 
-
-a| Geometry has an unexpected Material 
-<a| Did you reuse a Material from another Geometry and have inadvertently changed its properties? +(if so, maybe consider cloning: mat2 = mat.clone(); )  
-
-|===
-
-
-== Conclusion
-
-You have learned that the 3D world is a Scene Graph of Spatials: Visible Geometries and invisible Nodes. You can transform Spatials, or attach them to nodes and transform the nodes. ++
-Since standard shapes like spheres and boxes get old fast, continue with the next chapter where you learn to <<jme3/beginner/hello_asset#,load assets, such as 3-D models>>.

src/docs/asciidoc/jme3/beginner/hello_node_pt.adoc

@@ -1,426 +0,0 @@
-= jMonkeyEngine 3 Tutorial (2) - Hello Node
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:keywords: beginner, rootNode, node, intro, documentation, color, spatial, geometry, scenegraph, mesh
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Anterior: <<jme3/beginner/hello_simpleapplication_pt#,Hello SimpleApplication pt>>,
-Próximo: <<jme3/beginner/hello_asset_pt#,Hello Assets pt>>. 
-
-Neste tutorial nós daremos uma olhada na criação de uma cena 3D.
-
-*  Este tutorial assume que você save o que o <<jme3/the_scene_graph#, grafo de cena>> é. is.
-*  Para uma introdução visual, cheque o <<jme3/scenegraph_for_dummies#, Grafo de Cena para Novatos>>.
-
-Quando criando um jogo 3D
-
-.  Você cria alguns objetos como jogadores, edifícios, etc.
-.  Você adiciona os objetos para a cena.
-.  Você move, redimensiona, rotaciona, colore, e anima eles.
-
-Você aprendera que o grafo de cena representa o mundo 3D, e porque o nó raiz (rootNode) é importante. Você aprenderá como criar objetos simples, como deixá-los transportar dados customizados (como, por exemplo, pontos de saúde), e como “transformá-los por mover, escalonar e rotacionar. Você compreenderá a diferença entre os dois tipos de “Espaciais no grafo de cena: nós (Nodes) e geometrias (Geometries).
-
-
-== Amostra de código
-
-[source,java]
-----
-package jme3test.helloworld;
-
-import com.jme3.app.SimpleApplication;
-import com.jme3.material.Material;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.shape.Box;
-import com.jme3.math.ColorRGBA;
-import com.jme3.scene.Node;
-
-/** Sample 2 - Como usar os nós como agrupamentos para manipular os objetos da cena.
- * Você pode rotacionar, mover, e redimensionar manipulando os nós pai.
- * O nó raiz (rootNode) é especial: Somente o que está ligado ao nó raiz aparece na cena. */
-
-public class HelloNode extends SimpleApplication {
-
-    public static void main(String[] args){
-        HelloNode app = new HelloNode();
-        app.start();
-    }
-
-    @Override
-    public void simpleInitApp() {
-
-        /** cria uma caixa azul nas coordenadas (1,-1,1) */
-        Box box1 = new Box( Vector3f.ZERO, 1,1,1);
-        Geometry blue = new Geometry("Box", box1);
-        Material mat1 = new Material(assetManager, 
-                "Common/MatDefs/Misc/Unshaded.j3md");
-        mat1.setColor("Color", ColorRGBA.Blue);
-        blue.setMaterial(mat1);
-        blue.move(1,-1,1);
-
-        /** cria uma caixa vermelha logo acima da caixa azul em (1,3,1) */
-        Box box2 = new Box( Vector3f.ZERO, 1,1,1);
-        Geometry red = new Geometry("Box", box2);
-        Material mat2 = new Material(assetManager, 
-                "Common/MatDefs/Misc/Unshaded.j3md");
-        mat2.setColor("Color", ColorRGBA.Red);
-        red.setMaterial(mat2);
-        red.move(1,3,1);
-        
-        /** Cria um nó pivô em (0,0,0) e liga ele ao nó raiz(rootNode) */
-        Node pivot = new Node("pivot");
-        rootNode.attachChild(pivot); // põe este nó na cena
-
-        /** Liga os dois cubos ao nó *pivot*. */
-        pivot.attachChild(blue);
-        pivot.attachChild(red);
-        /** Rotaciona o nó pivô: Veja que ambas as caixas rotacionaram! */
-        pivot.rotate(.4f,.4f,0f);
-    }
-}
-----
-
-Construa e execute a amostra de código. Você deveria ver duas caixas coloridas inclinadas no mesmo ângulo.
-
-
-== Entendendo a Terminologia
-
-Neste tutorial você aprenderá alguns novos termos:
-[cols="2", options="header"]
-|===
-
-a|O que você quer fazer 
-a| Como você diz isso na terminologia JME3
-
-a|Colocar a disposição da cena 3D 
-a| Popular o grafo de cena
-
-a|Criar objetos da cena 
-a| Criar espaciais (Spatials) (e.g. criar geometrias (Geometries) )
-
-a|Fazer um objeto aparecer na cena 
-a| Anexar um espacial (Spatial) para o nó raiz rootNode
-
-a|Fazer um objeto desaparecer da cena 
-a| Retirar um espacial (Spatial) do nó raiz rootNode
-
-a|Posicionar/mover, virar, ou redimensionar um objeto 
-a| Transladar, ou rotacionar, ou escalar um objeto = transformar um objeto
-
-|===
-
-Toda aplicação JME3 tem um nó raiz (rootNode): Seu jogo automaticamente herda o objeto `rootNode` de SimpleApplication. Tudo anexado ao nó raiz (rootNode) é parte do grafo de cena. Os elementos do grafo de cena são os espaciais (Spatials).
-
-*  Um Spatial contém a localização, rotação e escala de um objeto.
-*  Um Spatial pode ser carregado, transformado, e salvo.
-*  Há dois tipos de Spatials: nós (Nodes) e geometrias (Geometries).
-[cols="3", options="header"]
-|===
-
-<a|  
-a| Geometria (Geometry) 
-a| Nó (Node) 
-
-a| Visibilidade: 
-a| Uma geometria (Geometry) é um objeto de cena visível 
-a| Um nó (Node) é uma “alavanca invisível para objetos da cena. 
-
-a| Propósito: 
-a| Uma geometria (Geometry) armazena a aparência de um objeto. 
-a| Um nó (Node) agrupa geometrias (Geometries) e outros nós (Nodes) juntos. 
-
-a| Exemplos: 
-a| Uma caixa, uma esfera, um jogador, um edifício, um pedaço de terreno, um veículo, mísseis, NPCs, etc… 
-a| O `nó raiz (rootNode)`, um nó de chão agrupando vários terrenos, um nó veículo-com-passageiros customizado, um nó jogador-com-arma, um nó de aúdio, etc… 
-
-|===
-
-
-== Entendendo o Código
-
-O que acontece no trecho de código? Você usa o método `simpleInitApp()` que foi introduzido no primeiro tutorial para inicializar a cena.
-
-.  Você cria a primeira geometria caixa.
-**  Crie uma forma caixa (Box) com extensões de (1,1,1), isto faz a caixa 2x2x2 unidades do mundo grande.
-**  Posicione a caixa em (1,-1,1) usando o método move() method. (Não mude o Vector3f.ZERO a menos que você queira mudar o centro de rotação)
-**  Envolva a forma caixa (Box) em uma geometria (Geometry).
-**  Crie um material azul
-**  Aplique o material azul para a geometria da caixa (Box Geometry). 
-[source,java]
-----
-
-    Box box1 = new Box( Vector3f.ZERO, 1,1,1);
-    Geometry blue = new Geometry("Box", box1);
-    Material mat1 = new Material(assetManager,
-      "Common/MatDefs/Misc/Unshaded.j3md");
-    mat1.setColor("Color", ColorRGBA.Blue);
-    blue.setMaterial(mat1);
-    blue.move(1,-1,1);
-----
-
-
-.  Você cria uma segunda geometria (Geometry) de caixa.
-**  Crie uma segunda forma caixa (Box) com o mesmo tamanho.
-**  Posicione a segunda caixa em (1,3,1). Isto é imediatamente acima da primeira caixa, com uma lacuna de 2 unidades do mundo entre elas.
-**  Envolva a forma caixa (Box) em uma geometria (Geometry).
-**  Crie um material vermelho
-**  Aplique o material vermelho para a geometria caixa (Box Geometry). 
-[source,java]
-----
-
-    Box box2 = new Box( Vector3f.ZERO, 1,1,1);
-    Geometry red = new Geometry("Box", box2);
-    Material mat2 = new Material(assetManager,
-      "Common/MatDefs/Misc/Unshaded.j3md");
-    mat2.setColor("Color", ColorRGBA.Red);
-    red.setMaterial(mat2);
-    red.move(1,3,1);
-----
-
-
-.  Você cria um nó (Node) pivô. 
-**  Nomeie o nó “pivot.
-**  Por padrão o nó (Node) é posicionado em (0,0,0).
-**  Anexe o nó (Node) ao nó raiz (rootNode).
-**  O nó (Node) não tem aparência visível na cena. 
-[source,java]
-----
-
-    Node pivot = new Node("pivot");
-    rootNode.attachChild(pivot);
-----
-
-Se você executar a aplicação somente com o código dado até aqui, a cena parece vazia. Isto é porque o nó (Node) está invisível, e você não tem ainda anexado quaisquer geometrias (Geometries) visíveis para o nó raiz (rootNode).. 
-
-
-.  Anexe as duas caixas para o nó pivô 
-[source,java]
-----
-
-        pivot.attachChild(blue);
-        pivot.attachChild(red);
-----
-
-Se você executar o aplicativo com somente o código dado até aqui, você vê dois cubos: Um vermelho imediatamente acima de um azul.
-
-.  Rotacione o nó pivô.
-[source,java]
-----
-        pivot.rotate( 0.4f , 0.4f , 0.0f );
-----
-
- Se você executar o aplicativo agora, você verá duas caixas uma no topo da outra - ambas inclinadas no mesmo ângulo.
-
-
-
-=== O que é um nó pivô (Pivot Node)?
-
-Você pode transformar (e.g. rotacionar) geometrias (Geometries) ao redor do próprio centro delas, ou ao redor de um ponto central definido pelo usuário. Um ponto central definido pelo usuário para um ou mais geometrias (Geometries) é chamado pivô.
-
-*  Neste exemplo, você agrupou duas geometrias (Geometries) por anexá-las para um nó pivô (Node). Você vê o nó (Node) pivô como um instrumento para rotacionar as duas geometrias (Geometries) ao mesmo tempo ao redor de um centro em comum. Rotacionar o nó (Node) pivô rotaciona todas as geometrias (Geometries) anexadas, de uma única vez. O nó pivô é o centro da rotação. Antes de anexar as outras geometrias (Geometries), tenha certeza que o nó pivô está em (0,0,0). Transformar um nó (Node) pai para transformar todas as crianças espaciais (Spatials) anexadas é uma tarefa comum. Você usará este método muito em seus jogos quando você mover espaciais (Spatials).
-
-Exemplos: Um veículo e seu motorista movem juntos; um planeta com sua lua orbitam o sol.
-
-*  Contraste este caso com a outra opção: Se você não criar um nó pivô extra e transformar uma geometria (Geometry), então toda transformação é feita relativa a origem da geometria (Geometry) (tipicamente o centro dela). +*Exemplos:*  Se você rotacionar cada cubo diretamente (usando `red.rotate(0.1f , 0.2f , 0.3f);` e `blue.rotate(0.5f , 0.0f , 0.25f);`), então cada cubo é rotacionado individualmente ao redor do seu centro. Isto é similar a um planeta rotacionando ao redor de seu próprio centro.
-
-
-== Como eu Populo o Grafo de Cena?
-[cols="2", options="header"]
-|===
-
-a| Tarefa…? 
-a| Solução! 
-
-a| Crie um espacial (Spatial) 
-a| Crie uma forma malha (Mesh), envolva ela em uma geometria (Geometry), e dê a ela um Material. Por exemplo: 
-[source,java]
-----
-Box mesh = new Box(Vector3f.ZERO, 1, 1, 1); // a cuboid default mesh
-Geometry thing = new Geometry("thing", mesh); 
-Material mat = new Material(assetManager,
-   "Common/MatDefs/Misc/ShowNormals.j3md");
-thing.setMaterial(mat);
-----
-
-
-a| Faça um objeto aparecer na cena 
-a| Anexe o espacial (Spatial) para o `nó raiz (rootNode)`, ou para qualquer no que esteja anexado para o nó raiz (rootNode). 
-[source,java]
-----
-rootNode.attachChild(thing);
-----
-
-
-a| Remova objetos da cena 
-a| Retire o nó espacial (Spatial) do `nó raiz (rootNode)`, e de qualquer nó que esteja vinculado ao nó raiz (rootNode). 
-[source,java]
-----
-rootNode.detachChild(thing);
-----
-
-[source,java]
-----
-rootNode.detachAllChildren();
-----
-
-
-a| Ache um nó espacial na cena pelo nome do objeto, ou ID, ou por sua posição na hierarquia pai-criança. 
-a| Olhe na criança ou pai do nó:  
-[source,java]
-----
-Spatial thing = rootNode.getChild("thing");
-----
-
-[source,java]
-----
-Spatial twentyThird = rootNode.getChild(22);
-----
-
-[source,java]
-----
-Spatial parent = myNode.getParent();
-----
-
-
-a| Especifique o que deveria ser carregado no início 
-a| Tudo que você inicializa e anexa ao `nó raiz (rootNode)` no método `simpleInitApp()` é parte da cena no início do jogo. 
-
-|===
-
-
-== Como eu transformo espaciais (Spatials)?
-
-Há três tipos de transformação 3D: Translação, Escalonamento, e Rotação.
-[cols="4", options="header"]
-|===
-
-a| Translação move espaciais (Spatials ) 
-a| eixo X-
-a| eixo Y 
-a| eixo Z 
-
-a|
-a|
-a|
-a|
-
-|===
-
-Para mover um espacial (Spatial) para coordenadas específicas, tais como (0,40.2f,-2), use:  
-
-[source,java]
-----
-thing.setLocalTranslation( new Vector3f( 0.0f, 40.2f, -2.0f ) );
-----
-
- Para mover um espacial (Spatial) por uma certa quantia, e.g. mais acima (y=40.2f) e mais atrás (z=-2.0f): 
-
-[source,java]
-----
-thing.move( 0.0f, 40.2f, -2.0f );
-----
-
- |+right -left|+up -down|+forward -backward|
-[cols="4", options="header"]
-|===
-
-a| Escalonamento redimensiona espaciais (Spatials) 
-a| eixo X-
-a| eixo Y 
-a| eixo Z 
-
-a|Especifique o fator de escalonamento em cada dimensão: tamanho, altura, comprimento. + um valor entre 0.0f e 1.0f diminue o espacial (Spatial); maior que 1.0f estica ele; 1.0f mantém ele o mesmo. + Usando o mesmo valor para cada dimensão escalona proporcionalmente, valor diferentes esticam ele. + Para escalonar um espacial (Spatial) 10 vezes mais longo, um décimo da altura, e manter o mesmo comprimento:  
-[source,java]
-----
-thing.scale( 10.0f, 0.1f, 1.0f );
-----
-
-a|length
-a|height
-a|width
-
-|===
-[cols="4", options="header"]
-|===
-
-a| Rotação gira espaciais (Spatials) 
-a| eixo X-
-a| eixo Y 
-a| eixo Z 
-
-a|Rotação 3-D é um pouco complicado (<<jme3/rotate#,aprenda os detalhes aqui>>)). em breve: Você pode rotacionar ao redor de três eixos: Pitch (X), yaw (Y), e roll (Z). Você pode especificar ângulos em graus por multiplicar o valor de graus com `FastMath.DEG_TO_RAD`. + Para rolar um objeto 180° ao redor do z axis: : 
-[source,java]
-----
-thing.rotate( 0f , 0f , 180*FastMath.DEG_TO_RAD );
-----
-
- Tip: Dica: Se sua idéia de jogo pede uma quantidade séria de rotações, é merecedor dar uma olhada em <<jme3/quaternion#,quaternion>>s, uma estrutura de dado que pode combinar e armazenar rotações eficientemente. 
-
-[source,java]
-----
-thing.setLocalRotation( 
-  new Quaternion().fromAngleAxis(180*FastMath.DEG_TO_RAD, new Vector3f(1,0,0)));
-----
-
-a|pitch = fazer um sinal de sim com sua cabeça
-a|yaw = agitar sua cabeça
-a|roll = inclinar sua cabeça
-
-|===
-
-
-== Como eu Resolvo Problemas com espaciais (Spatials)?
-
-Se você obtém resultados inesperados, cheque se você fez os seguintes enganos frequentes:
-[cols="2", options="header"]
-|===
-
-a| Problema? 
-a| Solução! 
-
-a| Geometria (Geometry) criada não aparece na cena. 
-a| Você anexou ela a (um nó que está vinculado a) o nó raiz (rootNode)? + Ela tem um Material? + Qual é sua translação (posição)? Ela está atrás da câmera ou coberta por uma outra geometria (Geometry)? + Ela é tão minúscula ou tão gigante para ver? + Ela está tão distante da câmera? (Tente link:http://jmonkeyengine.org/javadoc/com/jme3/renderer/Camera.html#setFrustumFar%28float%29[cam.setFrustumFar](111111f); para ver mais distante) 
-
-a| Um espacial (Spatial) rotaciona em maneiras inesperadas. 
-a| Você usou os valores em radianos, e não em graus? (Se você usou graus, multiplique eles com FastMath.DEG_TO_RAD para convertê-los para radianos) + Você criou o espacial (Spatial) na origem (Vector.ZERO) antes de movê-lo? + Você rotacionou ao redor do nó pivô ou ao redor de algo mais? + Você rotacionou ao redor do eixo certo? 
-
-a| Uma geometria (Geometry) tem cor (Color) ou Material inepserado. 
-<a| Você reusou um Material de uma outra geometria (Geometry) e tem inadvertidamente mudado suas propriedades? (Se sim, considere cloná-lo: mat2 = mat.clone(); )  
-
-|===
-
-
-== Como eu Adiciono um Dado Customizado para espaciais (Spatials)?
-
-Muitos espaciais (Spatials) representam personagens ou outras entidades que o jogador pode interagir. O código acima que rotaciona as duas caixas ao redor de um centro em comum (pivô) poderia ser usado para uma espaçonave estacionada em uma estação espacial orbital, por exemplo.
-
-Dependendo do seu jogo, entidades de jogo não somente mudam a posição delas, rotação ou escala (as transformações que você aprendeu). Entidades de jogo também têm propriedades personalizadas, como saúde, inventário carregado, equipamento usado para um personagem, ou força do casco e combustível restante para uma aeronave. Em Java, você representa dados de entidade como variáveis de classe, e.g. floats, Strings, ou Arrays.
-
-Você pode adicionar dados personalizados diretamente para qualquer nó (Node) ou geometria (Geometry). * Você não precisa estender a classe nó (Node) para incluir variáveis! *
-
-Por exemplo, para adicionar um número de id customizado para um nó, você usaria:
-
-[source,java]
-----
-pivot.setUserData( "pivot id", 42 );
-----
-
-Para ler o id do nó (Node) em outro lugar, você usaria:
-
-[source,java]
-----
-int id = pivot.getUserData( "pivot id" ); 
-----
-
-Por usar diferentes chaves de Strings (aqui a chave é o `id do pivô`), você pode recuperar e configurar vários valores para quaisquer dados que o espacial (Spatial) precisa carregar. Quando você iniciar a escrever seu jogo, você talvez adicione um valor de combustível para um nó carro, valor de velocidade para um nó avião, ou número de moedas douradas para um nó jogador, e muito mais. Entretanto, deve-se notar que somente objetos customizados que implementam Savable podem ser passados.
-
-
-== Conclusão
-
-Você aprenderu que sua cena 3D é um grafo de cena composto de espaciais (Spatials): Geometrias (Geometries) visíveis e nós (Nodes) invisíveis. Você pode transformar espaciais (Spatials), ou anexá-los a nós e transformar os nós. Você sabe a maneira mais fácil de como adicionar propriedades de entidade customizadas (tais como a saúde do jogador ou a velocidade do veículo) para espaciais (Spatials).
-
-Desde que formas padrões como esferas e caixas ficam velhas rápido, continue com o próximo capítulo onde você aprenderá a <<jme3/beginner/hello_asset#, carregar ativos, como por exemplo, modelos 3-D>>.

src/docs/asciidoc/jme3/beginner/hello_simpleapplication_pl.adoc

@@ -1,150 +0,0 @@
-= JME 3 Tutorial (1) - Tworzymy SimpleApplication
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:keywords: beginner, intro, documentation, init, Polish
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Poprzednie: <<jme3#installing_jmonkeyengine_3,Instalacja JME3>>,
-Następne: <<jme3/beginner/hello_node_pl#,Hello Node>> ++
-W tym tutorialu zakładamy, że już <<jme3#installing_jmonkeyengine_3,pobrałeś oraz odpowiednio ustawiłeś jMonkeyEngine3>> w swoim środowisku programistycznym. ++
-Tak więc jesteś gotowy na stworzenie pierwszej w gry w jMonkeyEngine3 ! Możesz korzystać z tych wprowadzających tutoriali pracując w praktycznie dowolnym środowisku programistycznym (IDE), takim jak jMonkeyEngine SDK, NetBeans, Eclipse, lub po prostu uruchamiać wszystko z wiersza poleceń. ++
-
-
-== Czas na SimpleApplication
-
-Stwórzmy pakiet `jme3test.helloworld` oraz plik `HelloJME3.java`. ++
-W środowisku NetBeans, klikamy prawym przyciskiem myszy na Source Packages :
-
-*  Wybieramy `New… &gt; Java Class` aby stworzyć nowy plik.
-*  Wprowadzamy nazwę klasy: `HelloJME3`
-*  Wprowadzamy wartość dla package: `jme3test.helloworld`
-*  Klikamy Finish.
-
-
-=== Przykładowy kod źródłowy
-
-Jak widzimy stworzony został plik HelloJME3.java. Skopiuj poniższy kod do niego:
-
-[source,java]
-----
-
-package jme3test.helloworld;
-import com.jme3.app.SimpleApplication;
-import com.jme3.material.Material;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.shape.Box;
-import com.jme3.math.ColorRGBA;
-/** Przykład 1 - zaczynamy prace z najprostsza aplikacja.
- * Wyswietlamy trojwymiarowy szescian i spogladamy na niego z wszystkich stron
- * poprzez ruch mysza lub klawisze WSAD. */
-public class HelloJME3 extends SimpleApplication {
-    public static void main(String[] args){
-        HelloJME3 app = new HelloJME3();
-        app.start();
-    }
-    @Override
-    public void simpleInitApp() {
-        Box b = new Box(Vector3f.ZERO, 1, 1, 1);
-        Geometry geom = new Geometry("Box", b);
-        Material mat = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
-        mat.setColor("Color", ColorRGBA.Blue);
-        geom.setMaterial(mat);
-        rootNode.attachChild(geom);
-    }
-}
-----
-
-Zbuduj i uruchom klasę HelloJME3. Jeżeli ukaże się jakiekolwiek okno dialogowe, potwierdź domyślne ustawienia.
-
-.  Zobaczysz okno, w którym wyświetlany jest sześcian.
-.  Możesz nawigować w oknie za pomocą klawiszy WASD oraz myszy.
-.  Naciśnij klawisz Escape, aby wyłączyć aplikację.
-
-Gratulacje, coś w końcu działa. Jak jednak to zrobiłeś?
-
-
-== Jak to wszystko zrozumieć?
-
-Poniżej przedstawione są podstawowe zasady, którymi “rządzą się gry wykonane w JME3:
-
-
-=== Start gry
-
-Zauważ, że klasa HelloJME3.java class rozszerza `com.jme3.app.SimpleApplication`, która z kolei jest podklasą `com.jme3.app.Application`. Każda gra wykonana w JME3 jest egzemplarzem `com.jme3.app.Application` (pośrednio lub bezpośrednio). ++
-Aby uruchomić grę, musisz na początku stworzyć egzemplarz odpowiedniej klasy, następnie wywołać jego metodę `start()`:
-
-[source,java]
-----
-
-HelloJME3 app = new HelloJME3();
-app.start();
-
-----
-
-*Porada:* Jeżeli jesteś zaawansowanym programistą języka Java możesz stworzyć kopię `SimpleApplication`  i używać jej jako szablonu dla własnych klas.
-
-
-=== Inicjalizacja sceny
-
-Ta prosta “gra składa się tylko z sześcianu. Poniżej zaprezentowany jest kod, który odpowiada za jego stworzenie, wypozycjonowanie, nadanie koloru oraz samo podpięcie do sceny. (Tymi wszystkimi szczegółami zajmiemy się nieco później.)
-
-[source,java]
-----
-
-    public void simpleInitApp() {
-        Box b = new Box(Vector3f.ZERO, 1, 1, 1); // tworzy ksztalt szescianu
-        Geometry geom = new Geometry("Box", b);  // tworzy geometrie szescianu z ksztaltu
-        Material mat = new Material(assetManager,
-         "Common/MatDefs/Misc/Unshaded.j3md"); // tworzy material
-        mat.setColor("Color", ColorRGBA.Blue); // ustawia kolor materialu
-        geom.setMaterial(mat);                   // przypisuje material do szescianu
-        rootNode.attachChild(geom);              // podpina szescian do sceny
-    }
-----
-
-Metoda `simpleInitApp()` jest automatycznie wywoływana raz, kiedy uruchamiana jest gra. W tej metodzie tworzysz lub wczytujesz obiekty zanim zacznie się gra! Tak wygląda standardowy proces:
-
-.  Przygotowanie obiektów gry:
-**  Stwórz lub wczytaj wszystkie obiekty i rozmieść je odpowiednio.
-**  Aby geometria (jak przykładowo pudełko) ukazała się na scenie, podepnij ją do `rootNode`.
-**  Przykłady: Wczytaj gracza, teren, niebo, wrogów, przeszkodzy i umieść je w odpowiednich miejsach.
-
-.  Przygotowanie zmiennych gry:
-**  Zmienne w grze “śledzą stan gry. Należy ustawić poprawne wartości początkowe.
-**  Przykłady: Ustaw `wynik` na 0, a `zdrowie` na 100% i tak dalej.
-
-.  Przygotowanie nawigacji:
-**  Poniższe klawisze są ustawione domyślnie:
-***  W,A,S,D – Poruszanie się
-***  Mysz i strzałki – Zmiana pozycji kamery
-***  Escape - Opuszczanie aplikacji
-
-
-
-W JME3 kluczowym obiektem jest `rootNode`. Wszystko co jest podpięte do rootNode pojawia się na scenie. Innymi słowy: Obiekt który został stworzony, ale nie jest podpięty do rootNode, pozostaje niewidoczny.
-
-
-== Podumowanie
-
-Te kilka linijek kodu, nie  nothing but display a static object in 3-D, but they already allow you to navigate around in 3D. Dowiedziałeś się również, że SimpleApplication jest naprawdę dobrym miejscem na start ponieważ masz już:
-
-*  metodę `simpleInitApp()` służąca inicjalizacji obiektów gry
-*  `rootNode` where you attach geometries to make them appear in the scene
-*  domyślne ustawienia nawigacyjne
-
-W prawdziwej grze, musisz:
-
-.  Initialize the game world,
-.  Trigger actions in the event loop,
-.  Respond to user input.
-
-W kolejnych tutorialach dowiesz się, jak te zadania mogą zostać wykonane w jMonkeyEngine! ++
-Przejdź do lekcji  <<jme3/beginner/hello_node_pl#,Hello Node>> , gdzie na początku pokażemy Ci więcej szczegółów how to initialize the game world, also known as the scene graph.
-'''
-
-Zobacz również: <<jme3/simpleapplication_z_wiersza_polecen#,SimpleApplication z wiersza poleceń>>

src/docs/asciidoc/jme3/beginner/hello_simpleapplication_pt.adoc

@@ -1,247 +0,0 @@
-= jMonkeyEngine 3 Tutorial (1) - Hello SimpleApplication
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:keywords: beginner, intro, documentation, init, simpleapplication, basegame
-:relfileprefix: ../../
-:imagesdir: ../..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-Previous: <<jme3#installing_jmonkeyengine_3,Instalando JME3>>,
-Next: <<jme3/beginner/hello_node_pt#,Hello Node pt>>
-
-*Pré-requisitos:* Este tutorial assume que você já tenha <<#,baixado o SDK da jMonkeyEngine>>.
-
-Nesta série de tutoriais, nós assumimos que você usa o <<sdk#,SDK>> da jMonkeyEngine. Como um desenvolvedor Java intermediário ou avançado, você rapidamente verá que, em geral, você pode desenvolver código da jMonkeyEngine em qualquer ambiente de desenvolvimento integrado (NetBeans IDE, Eclipse, IntelliJ) ou mesmo da linha de comando.
-
-OK, Vamos nos aprontar para criar nossa primeira aplicação jMonkeyEngine3.
-
-
-== Crie um Projeto
-
-Na SDK da jMonkeyEngine:
-
-.  Escolha Arquivo (File)→Novo Projeto (New Project)… do menu principal.
-.  No assistente de Novo Projeto, selecione o modelo JME3→Jogo Básico (Basic Game). Clique em prosseguir (Next). 
-..  Especifique um nome de projeto, e.g. “HelloWorldTutorial
-..  Especifique um caminho para armazenar seu novo projeto, e.g. um diretório projetosjMonkey no seu diretório de usuário.
-
-.  Clique em terminar (Finish). 
-
-Se você tem perguntas, leia mais sobre Criação de Projeto aqui.
-
-
-[TIP]
-====
-Nós recomendamos atravessar os passos você mesmo, como descrito nos tutoriais. Alternativamente, você pode criar um projeto baseado no modelo <<sdk/sample_code#,JmeTests>> no SDK da jMonkeyEngine. Isto criará um projeto que já contém as amostras jme3test.helloworld (e muitas outras). Por exemplo, você pode usar o projeto JmeTests para verificar se você tem a solução certa.
-====
-
-
-
-== Escreva uma aplicação de amostra
-
-Para este tutorial, você deseja criar um pacote `jme3test.helloworld` no seu projeto, e criar um arquivo `HelloJME3.java` nele. 
-
-No SDK da jMonkeyEngine:
-
-.  Dê um clique com o botão direito no nó pacotes de código-fonte (Source Packages) de seu projeto.
-.  Escolha Novo (New)… →Classe Java (Java Class) para criar um novo arquivo.
-.  Digite o nome da classe: `HelloJME3`
-.  Digite o nome do pacote: `jme3test.helloworld`.
-.  Clique em Finalizar (Finish).
-
-O SDK cria o arquivo HelloJME3.java para você.
-
-
-== Código de Amostra
-
-Substitua os conteúdos do arquivo HelloJME3.java com o seguinte código:
-
-[source,java]
-----
-
-package jme3test.helloworld;
-
-import com.jme3.app.SimpleApplication;
-import com.jme3.material.Material;
-import com.jme3.math.Vector3f;
-import com.jme3.scene.Geometry;
-import com.jme3.scene.shape.Box;
-import com.jme3.math.ColorRGBA;
-
-/** Sample 1 - começando com a mais simples aplicação JME 3.
- * Mostra um cubo 3D azul e veja todos os seus lados 
- * movendo o mouse e pressionando as teclas WASD. */
-public class HelloJME3 extends SimpleApplication {
-
-    public static void main(String[] args){
-        HelloJME3 app = new HelloJME3();
-        app.start(); // start the game
-    }
-    
-    @Override
-    public void simpleInitApp() {
-        Box b = new Box(Vector3f.ZERO, 1, 1, 1); // cria a forma do cubo na origem
-        Geometry geom = new Geometry("Box", b);  // cria a geometria do cubo a partir da sua forma
-        Material mat = new Material(assetManager,
-          "Common/MatDefs/Misc/Unshaded.j3md");  // cria um material simples
-        mat.setColor("Color", ColorRGBA.Blue);   // determina a cor do material para azul
-        geom.setMaterial(mat);                   // determina o material do cubo
-        rootNode.attachChild(geom);              // faz o cubo aparecer na cena
-    }
-}
-----
-
-Dê um clique com o botão direito na classe HelloJME3 class e escolha Executar (Run). Se um diálogo de configurações da jME3 aparecer, confirme as configurações padrão.
-
-.  Você deveria ver uma janela simples exibindo um cubo 3D.
-.  Pressione as teclas WASD keys e mova para navegar ao redor.
-.  Olhe no texto do FPS e na informação de contagem de objeto na esquerda-fundo. Você usará esta informação durante o desenvolvimento, e você removerá ela para a liberação. (Para ler os números corretamente, considere que as 14 linhas de texto contam como 14 objetos com 914 vértices.)
-.  Pressione Escape (Esc) para fechar a aplicação.
-
-Parabéns! Agora camos decobrir como isso funciona!
-
-
-== Compreendendo o código
-
-O código acima tem inicializado a cena, e iniciado a aplicação.
-
-
-=== Inicie a SimpleApplication
-
-Olhe na primeira linha. A classe HelloJME3.java estende `com.jme3.app.SimpleApplication`. 
-
-[source,java]
-----
-
-public class HelloJME3 extends SimpleApplication {
-  // seu código...
-}
-
-----
-
-Todo jogo JME3 é uma instância de `com.jme3.app.SimpleApplication`. A classe SimpleApplication gerencia seu grafo de cena 3D e automaticamente desenha ele para a tela – isto é, em breve, o que uma engine de jogo faz para você! 
-
-Você inicia todo jogo JME3 do método main(), como toda aplicação Java padrão::
-
-.  Instancie sua classe baseada em `SimpleApplication`
-.  Chame o método `start()` da aplicação para iniciar a engine de jogo. 
-
-[source,java]
-----
-
-    public static void main(String[] args){
-        HelloJME3 app = new HelloJME3(); // instanciar o jogo
-        app.start();                     // iniciar o jogo!
-    }
-
-----
-
-Este código abre sua janela de aplicação. Vamos aprender a por alguma coisa para a janela em seguinda.
-
-
-=== Entendendo a Terminologia
-[cols="2", options="header"]
-|===
-
-a|O que você quer fazer
-a|Como você diz isso na terminologia JME3
-
-a|Você quer criar um cubo.
-a|Eu crio uma geometria (Geometry) com uma forma de caixa (Box) 1x1x1
-
-a|Você quer usar uma cor azul.
-a|Eu crio um Material com uma propriedade cor (Color) azul
-
-a|Você quer colorir o cubo azul.
-a|Eu coloco o Material da geometria caixa (Box Geometry)
-
-a|Você quer adicionar o cubo para a cena.
-a|Eu anexo a geometria caixa (Box Geometry) para o nó raíz (rootNode)
-
-a|Você quer que o cubo apareça no centro.
-a|Eu crio a caixa (Box) na origem = em `Vector3f.ZERO`.
-
-|===
-
-Se você não esta familiar com o vocabulário, leia mais sobre o <<jme3/the_scene_graph#, Grafo de Cema>> aqui.
-
-
-=== Inicialize a Cena
-
-Olhe no resto da amostra de código. O método `simpleInitApp()` é automaticamente chamado uma vez no início quando a aplicação inicia. Todo jogo JME3 deve ter este método. No mpetodo `simpleInitApp()`, você carrega objetos do jogo antes que o jogo inicie.
-
-[source,java]
-----
-
-    public void simpleInitApp() {
-       // seu código de inicialização...
-    }
-
-----
-
-O código de inicialização de um cubo azul parece como se segue:
-
-[source,java]
-----
-
-    public void simpleInitApp() {
-        Box b = new Box(Vector3f.ZERO, 1, 1, 1); // cria uma forma cúbica de 2x2x2 na origem
-        Geometry geom = new Geometry("Box", b);  // cria a geometria do cubo a partir da sua forma
-        Material mat = new Material(assetManager,
-          "Common/MatDefs/Misc/Unshaded.j3md");  // cria um material simples
-        mat.setColor("Color", ColorRGBA.Blue);   // determina a cor do material para azul
-        geom.setMaterial(mat);                   // determina o material da geometria do cubo
-        rootNode.attachChild(geom);              // faz a geometria do cubo aparecer na cena
-    }
-
-----
-
-Um jogo JME típico tem o seguinte processo de inicialização:
-
-.  Você inicializa os objetos do jogo: :
-**  Você cria ou carrega objetos e posiciona eles.
-**  Você faz objetos aparecerem na cena por anexá-los ao  `nó raiz (rootNode)`.
-**  *Exemplos:* Carregar o jogador, terreno, céu, inimigos, obstáculos, …, e colocá-los nas suas posições de início.
-
-.  Você inicializa variáveis
-**  Você cria variáveis para rastrear o estado de jogo.
-**  Você configura as variáveis para os valores de início delas.
-**  *Exemplos:* Coloque a `pontuação` para 0, coloque a `saúde` para 100%, …
-
-.  Você inicializa as teclas e ações do mouse.
-**  As seguintes ligações de entrada já estão pré-configuradas:
-***  W,A,S,D keys – Mova ao redir da cena
-***  Movimento do mouse e teclas seta - Vire a câmera
-***  Escape (Esc) - Sai do jogo
-
-**  Defina suas próprias teclas adicionais e ações de clique do mouse
-**  *Exemplos:* Clique para atirar, pressione a Barra de Espaço para pular, …
-
-
-
-== Conclusão
-
-Você têm aprendido que uma SimpleApplication é um bom ponto de início porque ela fornece você com:
-
-*  Um método `simpleInitApp()` onde você cria objetos.
-*  Um `nó raiz (rootNode)` onde você anexa objetos para fazê-los aparecer na cena.
-*  Configurações de entrada padrão úteis que você pode usar para navegação na cena.
-
-Quando desenvolvendo uma aplicação de jogo, você irá querer:
-
-.  Inicializar a cena de jogo
-.  Disparar ações de jogo
-.  Responder à entrada do usuário.
-
-Agora os próximos tutoriais lhe ensinarão a como realizar estas tarefas com a jMonkeyEngine 3.
-
-Continue com o tutorial <<jme3/beginner/hello_node_pt#,Hello Node pt>>, onde você aprende mais detalhes sobre como inicializar o mundo do jogo, também conhecido como o grafo de cena.
-'''
-
-Veja também:
-
-*  <<#, Instalar a JMoneyEngine>>
-*  <<jme3/simpleapplication_from_the_commandline#, SimpleApplication da Linha de comando>>
-*  <<sdk/project_creation#,Criar um projeto JME3>>.

src/docs/asciidoc/jme3/beginner_ru.adoc

@@ -1,27 +0,0 @@
-= jMonkeyEngine 3: Hello World серия учебников
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-:relfileprefix: ../
-:imagesdir: ..
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-.  <<jme3/beginner/hello_simpleapplication_ru#,Знакомство с простым приложением>>
-.  <<jme3/beginner/hello_node_ru#,Знакомство с узлами>>
-.  <<jme3/beginner/hello_asset_ru#,Знакомство с ресурсами>>
-.  <<jme3/beginner/hello_main_event_loop_ru#,Знакомство с циклом обновления>>
-.  <<jme3/beginner/hello_input_system_ru#,Знакомство с системой ввода>>
-.  <<jme3/beginner/hello_material_ru#,Знакомство с материалом>>
-.  <<jme3/beginner/hello_animation_ru#,Знакомство с Анимацией>>
-.  <<jme3/beginner/hello_picking_ru#,Знакомство с комплектами>>
-.  <<jme3/beginner/hello_collision_ru#,Знакомство со столкновением>>
-.  <<jme3/beginner/hello_terrain_ru#,Знакомство с ландшафтами>>
-.  <<jme3/beginner/hello_audio_ru#,Знакомство с аудио>>
-.  <<jme3/beginner/hello_effects_ru#,Знакомство с эффектами>>
-.  <<jme3/beginner/hello_physics_ru#,Знакомство с физикой>>
-
-Получить исходный код можно по адресу link:http://code.google.com/p/jmonkeyengine/source/browse/trunk/engine/src/test/jme3test/helloworld/[jme3/src/test/jme3test/helloworld/].
-'''
-
-<<jme3_ru#,Вернуться к документации>>

src/docs/asciidoc/sdk_pt.adoc

@@ -1,150 +0,0 @@
-= Documentação jMonkeyEngine SDK
-:author:
-:revnumber:
-:revdate: 2016/03/17 20:48
-:keywords: documentation, tool, sdk
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-
-== Por quê jMonkeyEngine SDK?
-
-
-image::sdk/jme3-jmonkeyplatform.png[jme3-jmonkeyplatform.png,width="288",height="180",align="left"]
-
-O jMonkeyEngine SDK (_kit_ de desenvolvimento de software) é o ambiente de desenvolvimento de jogos recomendado para a biblioteca jMonkeyEngine 3.
-
-O jMonkeyEngine SDK é um ambiente de desenvolvimento integrado (Integrated Development Environment - IDE) que lhe provê plugins únicos para a criação de conteúdo de jogos jMonkeyEngine 3. Você pode link:https://github.com/jMonkeyEngine/sdk/releases/tag/stable[baixar e instalar o jMonkeyEngine SDK] como um ambiente de desenvolvimento de jogos completo e pronto para o uso, ao invés de utilizar uma IDE Java genérica. (<<jme3/beginner/what_s_an_ide#,O que é uma IDE>>?)
-
-* EM CONSTRUÇÃO *
-
-Since the jMonkeyEngine SDK is based on the link:http://platform.netbeans.org/[NetBeans Platform] (<<sdk/whynoteclipse#,Why not Eclipse RCP?>>), you have access to all of the developer tools in the link:http://www.netbeans.org/[NetBeans IDE], including a wide variety of deployment formats ranging from browser Applet and WebStart to desktop executables. Allthough we recommend the jMonkeyEngine SDK, experienced users can work with the jMonkeyEngine JARs in their favorite IDE, and choose to only use the jMonkeyEngine SDK to manage assets and JME3 binaries.
-
-
-[TIP]
-====
-Go to `Settings → Keymap` and choose your favorite keyboard profile: NetBeans default, Eclipse, IntelliJ, or others.
-====
-
-
-
-=== Documentation
-
-
-[TIP]
-====
-To get help and code samples right in the SDK, *press F1*, or press *ctrl-i* to enter a query in the super search box (top right)!
-====
-
-
-The built-in help system lets you browse a local copy of the documentation pulled from this wiki. It also contains code samples and info about installed plugins and generic IDE features.
-
-
-== All Features and Usecases
-
-
-=== Video Tutorials
-
-*SDK Use Case Tutorials*
-
-*  link:http://www.youtube.com/watch?v=-OzRZscLlHY[Video: jMonkeyEngine SDK Use Case Demo 1 (Quixote demo)]
-*  link:http://www.youtube.com/watch?v=6-YWxD3JByE[Video: jMonkeyEngine SDK Use Case Demo 2 (Models and Materials)]
-
-*SDK Tutorials*
-
-*  link:http://www.youtube.com/watch?v=M1_0pbeyJzI[Video: jMonkeyEngine SDK - Basics]
-*  link:http://www.youtube.com/watch?v=nL7woH40i5c[Video: jMonkeyEngine SDK - Importing Models]
-*  link:http://www.youtube.com/watch?v=DUmgAjiNzhY[Video: jMonkeyEngine SDK - Dragging&amp;Dropping Nodes]
-*  link:http://www.youtube.com/watch?v=ntPAmtsQ6eM[Video: jMonkeyEngine SDK - Scene Composing]
-*  link:http://www.youtube.com/watch?v=zgPV3W6dD4s[Video: jMonkeyEngine SDK - Terrain with Collision Shape]
-*  link:http://www.youtube.com/watch?v=Feu3-mrpolc[Video: jMonkeyEngine SDK - Working with Materials]
-*  link:http://www.youtube.com/watch?v=MNDiZ9YHIpM[Video: jMonkeyEngine SDK - Custom Controls]
-*  link:http://www.youtube.com/watch?v=oZnssg8TBWQ[Video: WebStart Deployment]
-*  link:http://www.youtube.com/watch?v=D7JM4VMKqPc[Video: Animation and Effect TrackEditing]
-
-
-image::sdk/jmonkeyplatform-docu-4.png[jmonkeyplatform-docu-4.png,width="421",height="298",align="right"]
-
-
-
-=== SDK User Guide
-
-*Getting Started*
-
-*  <<sdk/update_center#,Updating jMonkeyEngine SDK>>
-*  <<sdk/troubleshooting#,Troubleshooting>>
-
-*Generic Java Development Features*
-
-*  <<sdk/project_creation#,Project Creation>>
-*  <<sdk/code_editor#,Code Editor and Palette>>
-*  <<sdk/version_control#,File Version Control>>
-*  <<sdk/application_deployment#,Application Deployment (JAR, WebStart, Applet, Android)>>
-**  <<sdk/default_build_script#,Default Build Script>>
-**  <<jme3/android#,Android>>
-**  <<jme3/ios#,iOS>>
-
-*  <<sdk/debugging_profiling_testing#,Debugging, Profiling, Testing>>
-
-*Unique Game Development Features*
-
-*  <<sdk/model_loader_and_viewer#,Importing, Viewing, and Converting Models>>
-**  <<sdk/asset_packs#,Asset Packs>>
-
-*  <<sdk/scene_explorer#,The SceneExplorer>>
-image::jme3-built-in-help.png[jme3-built-in-help.png,width="400",height="260",align="right"]
-
-*  <<sdk/scene_composer#,Composing a Scene>>
-*  <<sdk/terrain_editor#,Terrain Editor>>
-*  <<sdk/sample_code#,Sample Code>>
-*  <<sdk/material_editing#,Material Editing>>
-*  <<sdk/font_creation#,Creating Bitmap Fonts>>
-*  <<sdk/effect_tracks#,Audio and Effect Track Editing>>
-*  <<sdk/attachment_bones#,Animation and Attachment Bones Editing>>
-*  <<sdk/filters#,Post-Processor Filter Editor and Viewer>>
-*  <<sdk/blender#,Blender Importer>>
-*  <<sdk/appstates#,App States and Controls>>
-*  <<sdk/vehicle_creator#,Vehicle Creator>>
-
-
-[NOTE]
-====
- jMonkeyEngine SDK is continuously improved, here are some link:http://code.google.com/p/jmonkeyengine/issues/list?can=2&q=label%3AProduct-Platform+Type%3DEnhancement&colspec=ID+Type+Status+Component+Priority+Product+Milestone+Owner+Summary&cells=tiles[changes and improvements for the future].
-====
-
-
-
-image::jme3/jmonkey-sdk-workflow.png[jmonkey-sdk-workflow.png,width="",height="",align="center"]
-
-
-
-== Advanced Usage
-
-*  <<sdk/use_own_jme#,Using your own (modified) version of jME3 in jMonkeyEngine SDK>>
-*  <<sdk/development/model_loader#,Create a custom model importer>>
-*  <<sdk/log_files#,Log Files>>
-*  <<sdk/increasing_heap_memory#,Increasing Heap Memory>>
-
-
-== Available external plugins
-
-*  <<jme3/contributions#,Contributions>>
-*  <<sdk/neotexture#,Neo Texture Editor for procedural textures>>
-*  link:http://www.youtube.com/watch?v=yS9a9o4WzL8[Video: Mesh Tool &amp; Physics Editor]
-*  And more…
-
-
-=== Development
-
-*  <<sdk/build_platform#,Building jMonkeyEngine SDK>>
-*  <<sdk/development#,Developing plugins for jMonkeyEngine SDK>>
-
-
-=== Status and Roadmap
-
-See link:http://www.jmonkeyengine.com/forum/index.php?topic=13511.0[this thread] on the jme forum for up-to-date info on current status and features.
-
-
-== A Little Bit of History
-
-The jMonkeyEngine SDK first set root during a link:http://www.jmonkeyengine.com/forum/index.php?topic=13070.0[discussion by Normen]. Although preceded by previous similar projects, this was the first, serious attempt with the core team's blessing. For some time the project was referred to merely as the “link:http://blogs.sun.com/geertjan/entry/youtube_movie_of_jmonkeyengine_on[Game Development Environment], or “GDE for short. During alpha, we refered to it as link:http://www.jmonkeyengine.com/forum/index.php?topic=13510.0[jMonkeyPlatform], and for beta it was eventually named jMonkeyEngine SDK.

src/docs/asciidoc/space_lion_on_game_assets.adoc

@@ -1,311 +0,0 @@
-= space_lion_on_game_assets
-:author:
-:revnumber:
-:revdate: 2016/03/17 20:48
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-
-== Space Lion on game assets
-
-image:space_lion_test.jpg[space_lion_test.jpg,width="",height=""]
-
-Hello, I want to talk about several aspects of making game assets. Some of them will refer to the free open source software Blender, but some of them will be valid in a more general way.
-
-If you're already an expert who makes 3d game assets for a living, this introduction might not be that much of a gain to you. There are other wiki pages describing how to get your Blender assets into a jME3 game or asset pack.
-
-Well, that said, let's start…
-
-
-=== 1. Different 3d modeling workflows
-
-There are many ways to model a 3d asset:
-
-*  Low-Poly-First
-*  High-Poly-First
-*  3D-Scan-First (a special kind of High-Poly-First)
-*  Topology-Sculpting
-
-
-==== 1.1 Low-Poly-First
-
-Based on reference images (drawn concept art or photographs or blueprints) you create a low-poly-mesh in a 3d modeling tool such as Blender. If you just want a quick test, you can stop here - just give your low-poly-mesh a material such as “wood or “iron or some procedural texture (NeoTexture plugin).
-
-But if you want higher quality game assets you will continue: Next, you would create an UV layout. This step is explained later in this tutorial. Basically the UV layout is needed for textures and normal maps.
-
-In order to get a fancy normal map for your low-poly-mesh, you would now add a “Multiresolution modifier, so you can sculpt details. There are two Multires modifiers available in Blender: “Catmull-Clark and “Simple (see image below)
-
-image:multires_modifiers.png[multires_modifiers.png,width="",height=""]
-
-When should you use which? Here is a comparison table:
-[cols="2", options="header"]
-|===
-
-<a| Catmull-Clark
-a| Simple
-
-a| + good for 'organic' models
-a| + good for 'technical' models
-
-a| + auto-smoothes everything
-a| + keeps sharp features
-
-a| - smoothes sharp features away
-a| - organic parts: smooth sculpting brush by hand
-
-|===
-
-Basically the teeth of a space monster need to be sharp, and I didn't find a good way - so I used “Simple first and then later, I used the smooth brush in sculpt mode. Maybe someone has a good idea for me?
-
-Another question is: Do I first give the model a texture or do I first sculpt the details? In my case, I did texture first, then sculpt the details - I was able to orient on the veins and other areas of the model. If you sculpt first, you will have to switch on the highest details of the Multires during texturing, which is slow. So, texture first is usually better.
-
-
-==== 1.2 High-Poly-First
-
-This workflow is best for technical stuff like “buildings or “sci-fi-weapons. It would not make sense, to sculpt on these objects like you would on an organic model. Instead, you create a very high-poly-mesh that has lots of little details like ridges, screws, gears, lamps, power cables, and so on.
-
-When you've finished this stage, you will now create a copy of the high-poly-version. In the copy you would find some key vertices that you find good and which represent the overall shape in the best possible way. You will delete all the other vertices, and maybe create some more in a similar way, but all low-poly this time.
-
-In the next stage you would create an UV layout for textures in the low-poly-version and project the high-poly-mesh of the original onto the low-poly-mesh via texture baking, using the “Bake &gt; Normals section in the “Render tab of the “Properties view of Blender. You must first select the high-poly-mesh, then shift-select the low-poly-mesh and chose [x]“Selected to Active.
-
-For a detailed workflow description of the baking-normals-process, there will be a section later in this tutorial, that will cover this subject.
-
-Another important note here: If you try to make “water tight models, needed for certain 3D algorithms, then you would normally only do this for the low-poly-version of your model. The high-poly-version can be modelled faster, because you will only need it as a base for the normal map or maybe for some still-render cutscenes.
-
-
-==== 1.3 3D-Scan-First
-
-This workflow is similar to the “High-Poly-First workflow. The original mesh is obtained via 3D scanning. If you don't know a lot about 3D scanning: You will be surprised how many good and cheap ways there are to get a 3D scan! Getting 3D scans can be as easy as using a free tool together with your webcam or mobile phone.
-
-You would then polish the 3D scan with tools like “Meshlab, to get a nice and complete version of your 3D Scan. Usually the scan will now consist of a vertex colored triangle mesh with a very high polygon count.
-
-The rest is similar to the High-Poly-First way of doing things: Make a copy of the high-poly-version, select some vertices and delete the others. You now have a low-poly-version. All you have to do now, is finding a way to project the vertex colors of the high-poly-version onto the low-poly-version as a texture - you would use texture baking for this (detailed description will follow).
-
-
-==== 1.4 Topology-Sculpting
-
-This workflow relies on a 'sculpting mode all from the start' approach: You sculpt the mesh from the beginning on and later you work similar to the 3D-Scan-First workflow (retopo the mesh and get a low poly version). In this video you can see somebody modeling a demon face with horns:
-image:youtube_opskpccfbr4[youtube_opskpccfbr4,width="",height=""]
-
-
-=== 2. Several hints for making game art
-[cols="2", options="header"]
-|===
-
-a| You want to…
-a| What you need to do:
-
-a| Make humans
-a| Get “makehuman +use it +export your humans to Blender +polish them +import them via the jME SDK.
-
-a| Sculpt like a pro
-a| Blender's sculpting mode is enough for beginners like me. +However, there are other tools like “Sculptris, “Z Brush, “Mudbox and more
-
-a| Make sci-fi assets
-a| Get yourself a collection of “greebles (little surface details and gismos) +combine them in numerous ways, +to achieve the high-poly sci-fi model of your dream +or just doom-style walls and machines +look for “shipyard 0.7 on BlendSwap.com
-
-a| Get free models
-a| Look at “OpenGameArt.org, “BlendSwap.com, “Turbosquid.com or similar sites +“OpenGameArt: Lots of models, all of them for games, not all of them Blender, all free +“BlendSwap: Lots of models, not all of them for games, all of them Blender, all free +“Turbosquid: Lots of models, not all of them for games, not all of them Blender, not all free +you will find a lot of models and textures on the internet. *
-
-|===
-
-(*) When they are licensed under CC0 or CC-BY, you can easily use them. CC-BY requires you to mention the original artist in a certain way in your games “credits roll. Some very good models are under CC-BY-SA, which means that your program must be under open source license when you want to use these models. Other licenses are +++<abbr title="GNU Lesser General Public License">LGPL</abbr>+++ (similar to CC-BY) and +++<abbr title="GNU General Public License">GPL</abbr>+++ (similar to CC-BY-SA). There are other licenses, licensing can be a complex topic…
-
-
-==== 2.1 Style: Old School versus New School
-
-Here is what I mean by those two different styles:
-
-image:old_school_vs_new_school_1_low.png[old_school_vs_new_school_1_low.png,width="",height=""]
-image:old_school_vs_new_school_2_low.png[old_school_vs_new_school_2_low.png,width="",height=""]
-image:old_school_vs_new_school_3_low.png[old_school_vs_new_school_3_low.png,width="",height=""]
-
-This is a typical New School bow for a fantasy setting:
-
-image:octavio_mendez_sanchez_durian_guardian_equipment.jpg[octavio_mendez_sanchez_durian_guardian_equipment.jpg,width="",height=""]
-[cols="2", options="header"]
-|===
-
-<a| Old School
-a| New School
-
-a| - looks simple
-a| + looks “cool
-
-a| + usually less work needed
-a| - usually more work needed
-
-a| + less details render faster
-a| - fine details demand complex shape (slow)
-
-a| + good enough for prototyping
-a| + more appealing to many modern gamers
-
-a| + cheap items for lower-level game characters
-a| + helps visualize maxed-out game characters
-
-a| + cultural style: humans, androids, …
-a| + cultural style: elves, telepathic aliens, …
-
-|===
-
-
-==== 2.2 Style: Comic-look versus Realistic look
-
-There are great differences between a scene that was made to look realistic and a scene that has this certain “comic-look (usually characters with crazy proportions: big heads, big eyes, extremely thin arms and legs).
-[cols="2", options="header"]
-|===
-
-<a| Comic-look
-a| Realistic look
-
-a| + can be achieved very quickly +(usually no normal maps etc.)
-a| - realistic models need a lot of work +(several textures like normal, specular, gloss)
-
-a| + more artistic freedom
-a| - artistic freedom is limited
-
-a| - not suitable for some applications
-a| + suitable for simulations and AAA games
-
-a| - usually animated by hand
-a| + can make use of motion capturing
-
-a| + can be combined with hand-made textures
-a| - need high quality textures to look convincing
-
-a| - hard to find free models all in the same style
-a| + easy to find models, because style always the same
-
-a| + can make violence look sweet
-a| - violence might offend some people
-
-|===
-
-This comparison is not complete by far. I'm quite sure that there are more lenses that you could observe these two opponents and compare them, to find the best suitable for your project.
-
-
-==== 2.3 Style: Be consistent!
-
-Whatever your style/look for your 3D project is - you should be consistent when making the art assets. What this means? Stick to one way of doing things, so that all art assets fit together harmonically. Usually this means that you will have a hard time doing your comic-look world or your fantasy / sci-fi setting.
-
-There are several parameters that must match:
-[cols="1", options="header"]
-|===
-
-a| What must I consider?
-
-a| high details *vs* low details
-
-a| fantasy tech *vs* logically engineered tech
-
-a| funny games *vs* serious games / simulations
-
-a| toon shading *vs* simple shading *vs* photorealistic shading
-
-a| colors and post processing filters should fit well
-
-a| old school *vs* new school
-
-a| comic look *vs* realistic look
-
-a| …
-
-|===
-
-
-==== 2.4 New Low Poly modeling
-
-There is an old way of doing Low-Poly and there is a new way of doing Low-Poly: In old games, you often saw assets with an ultra low poly count, mainly focussed on triangles. In newer game art you can often see lots of quads instead of triangles, which is mainly because this works best together with sculpting and animations.
-
-
-==== 2.5 LOD (Levels Of Detail)
-
-The jME engine supports LOD - the same model is represented in several ways: From high-detail to low-detail. The high-detail levels show the whole geometry (which is typically 10000 triangles for modern game characters), the lower levels reduce this geometry (you can actually control how many polygons, e.g. 5000, 2500, 1250, 625, …). The further away your model is, the fewer polygons are needed to represent its shape, because it will only be a few pixels large when this far away.
-
-Both the Ogre-exporter and the jME SDK provide ways to configure the LOD steps of your model.
-
-
-==== 2.6 Multiple versions for different purposes
-
-In addition to LOD, you might be interested in providing several versions of your model, for different purposes. Here are some examples of what I mean:
-
-*  Shotgun model: a) equipped or laying around / b) during reloading, with open-barrel-animation
-*  Rocket launcher model: a) version with 4 rocket heads / b) version with 3, 2, 1, 0 rocket heads
-*  Rocket launcher model: a) version with closed hatch / b) version with open hatch and warhead
-*  Car model: a) without a scratch / b) somewhat damaged, heavily damaged, totally wrecked
-*  3d Chat smiley: a) neutral face / b) workaround* for extreme shape change: laughing, surprised, angry…
-*  Evil samurai-demons: a) normal shape / b) sliced in two parts (several versions)
-
-(*) This workaround will not be necessary anymore as soon as the engine allows for shape key deformation animations. You can also rig a face with bones, if you know how to do it well.
-
-
-=== 3. UV mapping
-
-
-==== 3.1 Seams-Unwrap versus Auto-Unwrap
-
-
-==== 3.2 Few Isles versus Many Isles
-
-
-==== 3.3 Large Isles versus Small Isles
-
-
-==== 3.4 Margins - the answer to color bleeding
-
-
-==== 3.5 Details by Mesh versus Details by Texture
-
-
-=== 4. Rigging basics
-
-
-==== 4.1 Different types of rigs
-
-
-==== 4.2 Skinning with vertex group editing
-
-
-==== 4.3 Skinning with weight painting
-
-
-==== 4.4 Finding unassigned vertices
-
-
-==== 4.5 Posing with bone constraints
-
-
-=== 5. Texturing
-
-
-==== 5.1 Painting basic texture colors in 2d
-
-
-==== 5.2 Painting texture details in 3d
-
-
-==== 5.3 Baking texture with margin around isles
-
-
-==== 5.4 Other types of handmade textures
-
-
-==== 5.5 Baking normal maps
-
-
-==== 5.6 Other baking techniques
-
-
-==== 5.7 Texture coordinate recycling
-
-
-==== 5.8 Texture atlas sharing
-
-
-==== 5.9 Human faces and bodies
-
-
-=== The End
-
-Bye bye, polygon land, the Space Lion now rests to sleep. He will dream of digitally animated antilopes. He will dream of a glorious future for his favorite open source modeling tool. He will dream of the monkeys that live on their Java island. Another day, another project…

src/docs/asciidoc/space_lion_test.adoc

@@ -1,12 +0,0 @@
-= space_lion_test
-:author: 
-:revnumber: 
-:revdate: 2016/03/17 20:48
-ifdef::env-github,env-browser[:outfilesuffix: .adoc]
-
-
-test with appending ?do=edit to the url
-so <<space_lion_test?do=edit#,space_lion_test?do=edit>>
-emoji:
-
-test