пятница, 18 марта 2011 г.

Вышла jMonkeyEngine3 SDK Alpha-4 !!




13го марта вышла 4 версия движка JMonkeyEngine.

В данной версии движка появилось довольно много вкусных функций:

- визуальный редактор ландшафтов;

- пост-процесс отображение водных поверхностей;

- Depth Blur фильтр;

- улучшенная физическая модель;

И много многое другое.

Я на самом деле рад, что обратил внимание на столь приятный в использовании движок, который к тому же бесплатен и имеет поддержку столь обширного комьюнити. Ждем новых обновлений!

Ссылка на оригинальную новость: http://jmonkeyengine.org/2011/03/13/jmonkeyengine3-sdk-alpha-4-released/

четверг, 17 февраля 2011 г.

Java: Статья 2.1 Основы (переменные, строки, ввод данных)

Всем привет!

Статья 2 будет состоять из несколько частей. В каждой из них я постараюсь максимально сжато и, вместе с тем, доступно изложить основополагающие знания по языку Java.

Создайте в Java IDE новый класс с именем "hello" и внесите в него нижеприведенный код:


public class hello

{

public static void main(String[] args)
{
int x;
int y;
int z;

x = 10;
y = 20;
z = x+y;

System.out.println("Сумма x + y = "+ z);

}

}


Это элементарный код, но для освоения, думаю, подойдет для начала. Итак, мы определяем переменные x, y, z. А после этого задаем значения каждой из этих переменных.

Также необходимо обратить внимание на то, что переменные задаются как integer (int), то означает определенный тип переменной. Не будем вдаваться в подробности и объем памяти, который занимает та или иная переменная. Для ознакомления следует знать только то, что int-переменные представляют целочисленное значение (1, 2, 3, 4 и т.д.).

После определения переменных мы выводим на экран строку с помощью метода System.out.println. После этого выполняем программу и получаем значение z, которое является суммарным значением x и y.

Пока что ничего сложного, верно? :) Идем дальше. немного преобразуем программу. Взгляните на этот код:

import java.util.Scanner;


public class hello

{

public static void main(String[] args)
{
double x;
double y;
double z;

Scanner in = new Scanner(System.in);

System.out.print("Введите значение х: ");
x = in.nextDouble();

System.out.print("Введите значение y: ");
y = in.nextDouble();

z = x/y;

System.out.print("Сумма x + y = ");
System.out.print(z);

}

}


В данном примере появилось несколько новых элементов кода. Разберем все нововведения по порядку.

Для того, чтобы "оживить" программы, мы с Вами организуем ввод информации. Пока что это всего лишь значения двух переменных, но тем не менее, так программа становится зависимой от действий пользователя, что уже интереснее :)

Для чтения информации с консоли нам надо создать объект Scanner и связать его с стандартным входным потоком System.in. При этом мы импортируем одну из стандартных библиотек :

import java.util.Scanner;

Также, Вы не могли не заметить, что во втором примере переменные задаются как "double". данный тип наиболее распространен и используется для вычислений дробных значений.

И заключительным моментом является вывод результата вычислений на экран с помощью оператора System.out.print. Отличие print от println заключается в заполнении (и "не заполнении") строки для вывода информации. В данном случае мы получим визуально аналогичный результат вывода данных, при этом используя немного другой подход :)

Чтобы закрепить в голове и на бумаге полученные знания, рассмотрим еще один небольшой пример:

import java.util.Scanner;

public class hello
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);

System.out.print("Как Вас зовут? : ");
String name = in.nextLine();

System.out.print("Сколько буханок хлеба Вы хотите купить? : ");
int numb = in.nextInt();

double summ = numb*price;

System.out.println(name + ", Вам нужно потратить " + summ + " денег"
+ " на "+numb+" буханок хлеба");


}
public static final double price = 2.3;
}

Прежде всего, в третьем примере рассмотрен ввод текстовых данных (имени), что стоит взять на заметку :), а также глобальные переменные, которые остаются неизменными. такими переменными могут выступать значения, которые имеют определенно значение в материальном мире (тарифы по коммун платежам, цены на товары и т.д.)

Многие частные случаи, по темам, которые рассмотрены в статье не описаны, но лишь потому, что цель вводных статей - как можно быстрее и продуктивнее подковать пользователя в базовых знаниях языка программирования Java.

На этом пока что все, благодарю за внимание.


JMonkey: Статья 3. Работа с Asset'ами

Всем привет!

В рамках данной статьи мы научимся загружать 3D модели, а также текст в scenegraph, используя JME asset manager. Кроме того, мы рассмотрим форматы, которые использует JMonkey.

Прежде чем приступить к выполнению поставленной задачи, необходимо добавить библиотеку к созданному проекту.

Для этого щелкните правой кнопкой мыши по созданному проекту -> Properties -> Libraries -> Add Library -> jme3-test-data

Теперь мы готовы приступить к работе. Исходный код проекта выглядит следующим образом:

package mygame;

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;


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);

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/SimpleTextured.j3md");
mat_brick.setTexture("m_ColorMap",
assetManager.loadTexture("Textures/Terrain/BrickWall/BrickWall.jpg"));
wall.setMaterial(mat_brick);
wall.setLocalTranslation(2.0f,-2.5f,0.0f);
rootNode.attachChild(wall);

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);

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);

DirectionalLight sun = new DirectionalLight();
sun.setDirection(new Vector3f(-0.1f, -0.7f, -1.0f));
rootNode.addLight(sun);

}
}

Перед тем, как перейти к рассмотрению отдельных блоков кода, я бы хотел уделить внимание Asset Manager'y, который поставляется в пакете SDK JMonkey.

Основная задача любого "менеджера ресурсов", конечно же, структуризация содержимого проекта.

Asset - любой ресурс, который относится к проекту (звуки, текстуры, модели, сцены и т.д.).

Для максимального упрощения "чтения" содержимого проекта, asset'ы могут быть распределены по категориям (models, sounds, scenes .....)

Теперь пришло время перейти непосредственно к рассмотрению кода проекта.

Создаем фрагмент стены:

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/SimpleTextured.j3md");
mat_brick.setTexture("m_ColorMap",
assetManager.loadTexture("Textures/Terrain/BrickWall/BrickWall.jpg"));
wall.setMaterial(mat_brick);
wall.setLocalTranslation(2.0f,-2.5f,0.0f);
rootNode.attachChild(wall);

Если вы ознакомились с предыдущими статьями, то здесь вопросов не должно возникать. Единственное, на что стоит обратить внимание (раз уж мы рассматриваем Asset Manager), так это пути к контентным файлам (ресурсам проекта).

Смысл применения менеджера ресурсов виден не только в структуризации содержимого, а также в удобстве пользования.

Путь к ресурсу, как вы видите, указывается не в полной степени (C:\JMonkey\......), а лишь в рамках проекта.

Двигаемся далее:

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);

Этот блок кода отображает строку "Hello text" в нижней части экрана. мы прикрепляем текст к guiNode (спец узел для отображения плоских элементов). Иными словами, можно считать данную строку элементов интерфейса игры (довольно примитивным, но все же :) ).

Общий процесс инициализации строки :

1. определение шрифта отображения текста

2. определение размера текстовой строки

3. непосредственное содержимое строки

4. расположение текстовой информации на сетке координат экрана

5. присваивание hellotext элемента guiNode узлу


Первая же строка (при ее присутствии) отображает лишь элементы интерфейса, которые идут после ее прочтения. В случае ее отсутствия на экране отобразиться стандартная информация по рендерингу сцены.

Пример с guiNode.detachAllChildren();


Пример без guiNode.detachAllChildren();


Теперь перейдем к самому интересному - импорту модели в наш проект:

JMonkey использует для моделей формат OgreXML (.mesh.xml, .scene, .material, .skeleton.xml). Для импорта любой модели в данном формате необходимо изначально разместить все ресурсы по это модели в папку с требуемым именем, а папку в свою очеред в папку Models Asset Manager'a.

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);


Первая строка- загружаем spatial, вторая - задаем габариты от исходных (которые указаны при создании модели), третья - вращение модели вокруг оси y, четвертая - размещения модели в плоскостях z и y. И, конечно же, присваивание импортированной модели узлу rootNode для отображения в сцене.

Завершающим этапом станет добавление источника света для освещения нашей композиции:

DirectionalLight sun = new DirectionalLight();
sun.setDirection(new Vector3f(-0.1f, -0.7f, -1.0f));
rootNode.addLight(sun);

Подробнее использование освещения, как такового, мы рассмотрим в последующих статьях, пока что ограничимся лишь логическими элементами данного кода.

Изначально создается DirectionalLight sun (направленный источник света с именем sun). Затем устанавливается направление "деятельности" источника света.

Игровой проект вдоль и поперек будет состоять из контента, который Вы заготовите для него, однако представление о элементарном создании объектов в JMonkey (тот же куб) поможет на практике в тестировании отдельных аспектов движка или технологической демо-версии игры.

Теперь в Вашем (и моем :) ) арсенале имеются инструменты и, что самое главное, знания для создания статической сцены, ее рендеринга с дальнейшим добавлением объектов (будь то геометрический объект или элемент интерфейса) и их преобразованием относительно исходника, созданного в 3D редакторе.


JMonkey: Статья 2.2 Понятия Node (узел) и Geometry (геометрическая форма)

Итак, подведем итоги статьи 2.1 и упорядочим все вышеизложенное.

Spatial -абстрактная структурная совокупность преобразований (вращение, изменение габаритов и т.д.)

Node (узел) - грубо говоря, это "невидимый рычаг" управления. Node группирует геометрические объекты и другие Nodes вместе (когда вы преобразуете исходный узел, то происходит преобразование "наследующих" узлов).

Geometry - представляет видимый трехмерный объект. Геометрический объект содержит в себе форму исходного объекта, а также материал (цвет, текстура, прозрачность и т.д.).

Теперь поговорим немного о трансформировании объектов. Всего трансформации объекта можно проводить по трем направлениям: движение, вращение, изменение габаритов объекта (resizing).

Изменение координат объекта:

thing.setLocalTranslation( new Vector3f( 0.0f, 40.2f, -2.0f ) );

В данном случае thing - объект, который подвергается преобразованию (изменение координат объекта).

Чтобы просто передвинуть объект на определенное расстояние вдоль той или иной оси, можно использовать код:

thing.move( 0.0f, 40.2f, -2.0f );

Опять таки, объектом преобразования выступает "thing".

Для изменения размеров Spatial'a, необходимо изменить параметр величины по определенной координате: длина, ширина, высота. Значение между 0,0 и 1,0 определит множитель для значения переменной на убывание и, само собой разумеется, между 1,0 и выше - увеличение (увеличение габарита объекта).

thing.setLocalScale( 10.0f, 0.1f, 1.0f );

thing.scale( 10.0f, 0.1f, 1.0f );

Как и в случае с передвижением используется "local" форма кода и форма обыденного, грубо говоря, изменения параметра величины.

Теперь поговорим о вращении объектов. тут необходимо вспомнить геометрию, а также тот факт что вращение возможно вокруг определенной оси. также стоит отметить, что в JMonkey значения вращение задается не в градусах, а в радианах. Наглядный пример:

thing.rotate( 0f , 0f , FastMath.PI );

Здесь происходит вращение объекта thing вокруг оси z на 180 градусов. Чтоб окончательно внести ясность,

(0 - 360 град) = (0.0f to 6.28f радиан).


В статье были рассмотрены базовые особенности и отличия Node, Geometry, Spatial, а также методы и способы преобразования тех или иных объектов (естественно на начальном уровне пока что :) ).

О практическом применении накопленных знаний по движку JMonkey пока что, говорить не приходится, но цикл статей продолжается. А это значит, что с каждым напечатанным словом, мы все ближе к созданию примитивной сцены с экспортированием объектов и их расстановкой. Впрочем, этот момент будет рассмотрен в последующих статьях :)

До встречи!

среда, 16 февраля 2011 г.

Java: Статья 1. Подготовка к работе

Первое, с чем сталкиваются многие пользователи, которые решили освоить язык программирования Java, это проблемы с компиляцией кода как такового. Проблемы возникают по разным причинам. Дабы искоренить все возможные трудности и неудобства я решил изложить весь процесс подготовки в данной статье.

Прежде всего нам потребуется среда разработки (JDK). Не путайте JRE (среда для запуска) и JDK (среда разработки). На момент написания, к скачиванию доступна версия Java 6 Update 24.

После скачивания и установки среды разработки необходимо прописать пути, по которым ОС будет обращаться к исполняемым файлам JDK.

Мой компьютер -> Свойства -> Дополнительные параметры системы -> Параметры среды -> Переменная Path (в окне системных переменных). Необходимо добавить путь к исполняемым файлам Java в начало строки и отделить ";%" от последующей переменной. Приблизительно это будет выглядеть так:


Дабы проверить работоспособность и убедиться в том, что все сделано правильно, проведем небольшой тест.

Создайте текстовый файл с именем "test" и смените его расширение на " .java". Впишите в новосозданный файл код:

class test

{

public static void main(String[] args)

{

System.out.println("Testing.....testing.....");

}

}

Сохраните изменения и запустите командную строку (Win+R и пропишите cmd).

Установите путь к java-файлу, а затем пропишите:

javac test.java

а после этого

java test

Результатом выполненных действий будет отображения заданной строки.


Пока что не будем вдаваться в подробности и разбору кода, главная цель, на данном этапе, это подготовка среды разработки Java к работе.

Опять таки, цель этой статьи подготовить пользователя к дальнейшим манипуляциям с кодом и освоению языка программирования.

Само собой разумеется, что выполнять все операции посредством командной строки было бы не совсем разумно (при существовании IDE ). В связи с этим на Ваше усмотрение, Вы можете воспользоваться такими Java IDE как Eclipse, NetBeans и пр. Для себя я выбрал Eclipse и ни чуть не жалею :)

Вот в общем то и все, что касается подготовки среды разработки. Если возникли вопросы, то смело пишите сообщения в коментариях к статьям.

Всего доброго, спишемся! :)

вторник, 15 февраля 2011 г.

JMonkey: Статья 2.1 Понятия Node (узел) и Geometry (геометрическая форма)

Всем привет.

Данная статья будет состоять из двух частей. В первой части мы рассмотрим с Вами такие важные понятия как Node и Geometry применительно к JMonkey.

Вторая часть будет посвящена углубленному рассмотрению использования (в данном случае модификации) узлов (Nodes), а также отличиям абстрактных объектов (Nodes) от геометрических (Geometry).

Цель, которая преследуется при разделении на подстатьи всего лишь одна - максимальное упрощение восприятия читателем (то есть Вами) материала, который изложен на страницах моего блога.

Итак, начнем.

Построение трехмерной игры начинается с создания сцены и некоторых объектов. Вы расставляете объекты (препятствия, бонусы и т.д.) на сцене, а затем вращаете, анимируете, изменяете их размер и т.д.

Предполагая, что Вы ознакомились с первой статьей по JMonkey, я не буду расписывать процесс создания проекта в JMonkey IDE.

Исходный код данной статьи выглядит таким образом:


package mygame;

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;


public class HelloNode extends SimpleApplication {

public static void main(String[] args){
HelloNode app = new HelloNode();
app.start();
}

@Override
public void simpleInitApp() {

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/SolidColor.j3md");
mat1.setColor("m_Color", ColorRGBA.Blue);
blue.setMaterial(mat1);

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/SolidColor.j3md");
mat2.setColor("m_Color", ColorRGBA.Red);
red.setMaterial(mat2);

Node pivot = new Node("pivot");
rootNode.attachChild(pivot);

pivot.attachChild(blue);
pivot.attachChild(red);


pivot.rotate( 0.4f , 0.4f , 0.0f );

}
}


Скомпилируйте и запустите пример. На экране должны отображаться два кубика.


Введем новые понятия согласно терминологии движка JMonkey.

  1. SceneGraph представляет собой трехмерный мир
  2. Объекты SceneGraph (в данном случае кубики) называют Spatial (грубо говоря, это совокупность информации об объекте:местоположении, вращении, размере и т.д.)
  3. Spatial может быть загружен, трансформирован, сохранен.
  4. Существует два вида Spatial (Node и Geometry).
  5. Для добавления Spatial к SceneGraph, вы прикрепляете Spatial к rootNode. Следовательно все, что прикреплено к rootNode яляется частью Scenegraph.

Теперь давайте рассмотрим данный код.

Создание первого кубика:


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/SolidColor.j3md");
mat1.setColor("m_Color", ColorRGBA.Blue);
blue.setMaterial(mat1);


Прежде всего, не забываем о том, что все манипуляции с объектами сцены мы осуществляем, используя метод simpleInitApp() (см. Статью 1).

Из кода видно, что мы создаем форму для куба (задаются параметры длины,ширины и высоты, а также расположение относительно центра координат).

Затем, создаем геометрический объект сцены, используя Spatial первого куба. Далее создается материал, которому присваивается определенный цвет (в данном случае синий), а затем применяется к ранее созданной геометрии куба.

Алгоритм создания второго куба аналогичен первому.

Следующий шаг - создание Node (узла).

Node pivot = new Node("pivot");
rootNode.attachChild(pivot);

Здесь стоит отметить тот факт, что сам по себе узел не отображается в рендер-окне сцены, а существует как некая абстрактная форма.

Далее мы закрепляем наши кубики за созданным узлом pivot:

pivot.attachChild(blue);
pivot.attachChild(red);

При прочтении документации, у меня невольно возник вопрос: "зачем привязывать кубы к узле, если их и так можно отобразить на сцене?". Логика моментально подсказал ответ :)

Смысл привязывания кубов к узлу в данном примере состоит в том, что при таком расположении вещей у нас появляется возможность манипулировать геометрическими объектами, задавая параметры для узла, что и доказывает последняя строка кода:

pivot.rotate( 0.4f , 0.4f , 0.0f );


Надеюсь, что с созданием узлов ни у кого не возникнет проблем. Подробнее о Nodes ( будем уже переходить на терминологию JMonkey :) ) Вы узнаете во второй части статьи.

С уважением, DanielDredd.


JMonkey: Статья 1. Первое приложение

Всем привет. Это первая статья по освоению средства разработки игр и приложений - JMonkey, в основе которого лежит язык программирования - Java.

В первой статье мы рассмотрим создание элементарного приложение с использованием средств, которые поставляются вместе с SDK движка.

первое, что нам предстоит сделать - это создать проект в JME3. Запускаем JMonkeyPlatform. затем в навигационном меню выбираем File -> New Project -> BasicGame.


Указываем название проекта, которое Вам больше по душе и нажимаем кнопку Finish.

Теперь у нас на руках есть каркас нашего проекта. Теперь пришло время создать класс HelloJME3. Сделать это можно путем открытия подменю Source Packages -> MyGame навигационного меню Projects и добавления нового Java Class'а с помощью правого клика мышкой, как показано на нижеприведенном рисунке.


После этого делаем двойной клик на "новорожденном" классе и заменим существующий код на этот:


package mygame;

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;


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/SolidColor.j3md");
mat.setColor("m_Color", ColorRGBA.Blue);
geom.setMaterial(mat);
rootNode.attachChild(geom);

}
}

Чтобы проверить работоспособность нашего первого приложения, нажимаем F6 (запуск исходного проекта), затем вбираем режим отображения и нажимаем "Ок".

Конечным результатом будет отображение синего куба и возможность перемещения камеры клавишами W,S,A,D.


Надеюсь с этим не возникло проблем. Теперь разберем код, который мы только что использовали в данном приложении.

Прежде всего, стоит отметить то, что класс HelloJME3 расширяет com.jme3.app.SimpleApplication, который в свою очередь является подклассом com.jme3.app.Application.

Каждая игра, основанная на JMonkeyEngine является следствием использования com.jme3.app.Application.

Для запуска JME3 игр мы инициализируем Application - основанный класс и затем вызываем метод (функцию) start():

HelloJME3 app = new HelloJME3();
app.start();

После вызова метода start() происходит инициализация сцены:


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/SolidColor.j3md"); // создаем простой материал
mat.setColor("m_Color", ColorRGBA.Blue); // задаем цвет материала
geom.setMaterial(mat); // применяем материал к созданной геометрии куба
rootNode.attachChild(geom); // привязываем куб к созданной сцене
}

Метод simpleInitApp() автоматически вызывается в начале каждой JME3 игры. В этом методе Вы создаете или загружаете объекты до старта самой игры.

Иными словами, можно представить данный процесс так:

1. Импортируем модели, текстуры, звуки и т.д.

2. Устанавливаем переменные для игры (здоровье, количество патронов и т.д.)

3. Подключаем управление.


Очень важным объектом является rootNode. Игра будет автоматически связана с данным объектом. Каждый элемент, который будет отображен в сцене так или иначе взаимодействует с объектом rootNode.

Вот пожалуй и все по поводу первого приложения. В данной статье были рассмотрены следующие моменты:

- инициализация сцены simpleInitApp

- создание и расположение примитивных объектов на сцене

- отображение объектов сцены с помощью объекта rootNode.

Надюсь, что все вышеизложенное поможет Вам сделать первый шаг к разработке игры на JMonkeyEngine!


До скорых встреч!