Готовый перевод Ogre3D Basic Tutorials / Базовые туториалы Ogre3D: Basic Tutorial 6: The Ogre Startup Sequence

ВВЕДЕНИЕ В УРОК

В этом туториале в узнаете как написать простое Ogre приложение с нуля.

ДЛЯ НАЧАЛА

ПЕРВОНАЧАЛЬНЫЙ КОД

В этом туториале простой каркас станет для нас отправной точкой.

ПРЕДУПРЕЖДЕНИЕ
Прежде чем продолжите, убедитесь, что у вас проект создан, и что он имеет два файла: заголовочный и cpp.
Если вы использовали Ogre Tutorial Wiki Framework, удалите из него BaseApplication.h и BaseApplication.cpp.

Убедитесь, что вы можете скомпилировать этот код, прежде чем продолжать.

Код будет вообще ничего не делать - он будет выходить сразу после запуска.

Не волнуйтесь, после того как пройдёте через это руководство, мы выйдем на полнофункциональные приложения OGRE.

КРАТКОЕ ОПИСАНИЕ ПРОЦЕССА ЗАПУСКА

Как только вы поймете, что за процессы происходят "внутри", запустить Ogre станет гораздо легче.

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

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

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

Базовый жизненный цикл Ogre выглядит подобно этому:

1.Создать объект Root.

2.Определить ресурсы которые Ogre будет использовать.

3.Выбрать и настроить систему рендеринга (DirectX, OpenGL, и так далее).

4.Создать окно рендеринга (RenderWindow) (окно в котором Ogre рисует всё).

5.Инициализировать все ресурсы которые вы будете использовать.

6.Создать сцену из этих ресурсов.

7.Настроить все остальные библиотеки и плагины.

8.Создать любое количество обработчиков кадров.

9.Запустить цикл рендеринга.

В этом уроке мы пройдемся по каждому пункту довольно глубоко.

Обратите внимание что, вы должны сделать шаги 1-4 в по порядку, шаги 5 и 6 (инициализация ресурсов и создание сцены) можно позже встроить в ваш процесс запуска, если вам нравится.

Вы должны инициализировать плагины и создать "слушателей кадров" перед шагами 5 и 6 если вы этого хотите, но вы не должны делать это до окончания шага 4.

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

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

ЗАПУСК OGRE

СОЗДАНИЕ ОБЪЕКТА ROOT

Объект Root является ядром движка OGRE, и должен быть создан прежде чем вы начнёте что либо делать с движком.

Нам нужно добавить следующие члены в наш класс BasicTutorial6:

Также добавьте следующие строчки в заголовочный файл:

Затем настройте конструктор и деструктор для работы с ними:

И затем в BasicTutorial6::go мы создаём новый объект класса Ogre::Root:

Конструктор класса Ogre::Root принимает три параметра:

pluginFileName ("plugins.cfg") - полный путь к файлу где прописаны все плагины.

configFileName( "ogre.cfg") - полный путь к файлу конфигурации
(который говорит движку какое устройство использовать, настройки графики и так далее).

logFileName("Ogre.log") - полный путь к файлу журнала движка в который OGRE записывает всё что происходит внутри него.

Мы могли бы оставить эти значения по умолчанию, но для того чтобы наше приложение работало с предварительно собранным OGRE SDK, где имя файла конфигурации плагинов отличается в зависимости от того в отладочном режиме (Debug) собран движок или окончательном (Release), мы должны передать наш параметр mPluginsCfg в конструктор, так как имя конфигурационного файла будет 'plugins_d.cfg' при запуске в режиме отладки.

Идем дальше - компилируем и запускаем наше приложение.

Выглядит так как будто ничего не происходит, но если вы откроете Ogre.log, то вы увидите то что Ogre запустился, инициализировался и завершил работу.

Также вы должны увидеть что он проанализировал найденные и установленные плагины перечисленные в 'plugins.cfg'.

РЕСУРСЫ

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

Вы можете найти это в каталоге bin/release вашего SDK.

Следующая вещь которую мы должны сделать - определить ресурсы используемые нашим приложением.

Это могут быть текстуры, модели, скрипты и прочее.

Мы не будем проходить всё, что нужно знать о ресурсах в этом учебнике.

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

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

Для этого мы добавим каждый каталог с ресурсами в ResourceGroupManager.

Добавьте следующий член класса в наш класс BasicTutorial6:

Затем поместите его в список инициализации конструктора, как в случае с 'mPluginsCfg'.

Нам нужно подключить Ogre::ConfigFile чтобы использовать класс-анализатор конфигурационных файлов Ogre.

Добавьте это в самый верх файла 'BasicTutorial6.cpp':

Теперь нам нужно добавить mResourcesCfg в release/debug логику в начало нашей "go" функции:

Это необходимо потому что имя файла с ресурсами отличается в release и debug.

Теперь мы можем действительно проанализировать некоторые ресурсы Ogre.

Добавьте следующий код в BasicTutorial6::go:

Здесь используется класс ConfigFile для того чтобы прочитать все ресурсы из файла "resources.cfg", но оно не загружает их (это нужно делать вручную).

Имейте ввиду что, в вашем приложении вы можете использовать свой анализатор конфигурационных файлов и свой формат этих файлов. Если вы хотите вы можете заменить ConfigFile на свой.

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

Теперь мы имеем проанализированный файл конфигурации, нам нужно добавить разделы в ResourceGroupManager.

Следующий код перебирает проанализированный конфигурационный файл и добавляет каждый элемент в ResourceGroupManager с помощью метода addResourceLocation:

Эта функция добавляет все ресурсы из файла конфигурации, но она только говорит Ogre, где они находятся.

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

Мы обсудим это позже в функции "Инициализация ресурсов".

Если вы соберете и запустите приложение сейчас, то вы можете увидеть в "Ogre.log", что Огре создал группы ресурсов и проанализировал ресурсы в этих группах

СОЗДАНИЕ СИСТЕМЫ РЕНДЕРИНГА

Дальше нам нужно выбрать системы рендеринга (RenderSystem, такую как OpenGL или DirectX) и настроить её.

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

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

Во-первых, нам нужно добавить новый член класса в свой класс BasicTutorial6 для хранения наших окон - Ogre:: RenderWindow:

Добавьте следующий код в метод BasicTutorial6::go:

В первой части мы пытаемся восстановить конфигурацию из файла.

Если эта функция возвращает false, это значит что файл не существует и мы должны показать диалог конфигурации, что мы и делаем во второй части.

Также оно вернет false если пользователь отменил диалог нажав Cancel, если так то вы выходим из приложения.

В этом примере мы выходим если возвращено false.

Нам нужно перехватывать исключения. Если вы используете эту технику на практике, то я бы порекомендовал перехватывать исключения при запуске чтобы мы могли удалить ogre.cfg в блоке catch.

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

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

Ваше приложение может также вручную настроить RenderSystem, если вы решите использовать нечто иное, чем окно конфигурации Ogre.

Типичный пример этого выглядит так:

Вы можете использовать функцию Root:: getAvailableRenderers чтобы узнать, какие RenderSystems доступны для вашего приложения для использования.

После того как вы получили RenderSystem, вы можете использовать RenderSystem::getConfigOptions, чтобы увидеть, какие опции доступны для пользователей.

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

СОЗДАНИЕ ОКНА РЕНДЕРИНГА

Теперь, когда мы выбрали RenderSystem, нам нужно окно в котором Ogre будет рендерить.

Есть на самом деле много вариантов, как это сделать, но мы выберем самый простой.

Если вы хотите создать окно визуализации, то это сделать очень легко.

Добавьте следующий код в BasicTutorial6::go:

Этот вызов инициализирует RenderSystem которую установили в предыдущем разделе.

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

Другой способ состоит в том, что вы можете использовать окна созданные с помощью Win32 API, wxWidgets или Qt, и так далее.

Небольшой пример того, как сделать это под Windows, будет выглядеть примерно так:

Обратите внимание, что вам все равно придется вызывать Root::initialise, но первый параметр установлен в false.

Затем вы должны получить HWND - это дескриптор окна в котором Ogre будет рендерить.

Как вы это будете делать, это определяется тем API который вы используете (и под Linux это было бы немного по-другому).

После того как вы получили дексриптор, вы должны, используя NameValuePairList присвоить дескриптор параметру "externalWindowHandle".

Метод Root::createRenderWindow может быть использован для создания RenderWindow из окна вы которое уже создали.

Больше информации по этой функции вы можете найти в API документации.

ИНИЦИАЛИЗАЦИЯ РЕСУРСОВ

Теперь, когда у нас есть наш объект Корень (Root) и наши объекты RenderSystem и RenderWindow, созданные и готовые, мы очень близко к тому, чтобы быть готовыми создать нашу сцену.

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

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

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

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

Мы делаем это, разделяя ресурсы на секции и только инициализируя их, поскольку мы идём.

Мы не будем охватывать это в этой обучающей программе, как бы то ни было. Смотри Resources (Ресурсы) и ResourceManagers (мененджер ресусов) для полной обучающей программы, посвященной ресурсам.

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

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

Добавьте следующий код в BasicTutorial6::go:

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

СОЗДАНИЕ СЦЕНЫ

Далее нам нужно создать сцену.

Вы должны знать, что есть три вещи, которые должны быть сделаны прежде, чем Вы начнете добавлять вещи к сцене:
1.создание SceneManager(менеджера сцены).
2.создание Камеры.
3.создание Viewport(окно просмотра).

Перед продолжением давайте добавим, что еще многие включают в вершину нашего файла BasicTutorial6.cpp:

СОЗДАНИЕ SCENEMANSGER(менеджер сцен)

Во-первых, добавьте нового частного участника данных к классу BasicTutorial6:

И затем добавьте следующий код к BasicTutorial6::go:

СОЗДАНИЕ КАМЕРЫ

Во-первых, добавьте нового частного участника данных к классу BasicTutorial6:

А затем добавьте вот этот код в BasicTutorial6::go:

ДОБАВЛЕНИЕ VIEWPORT(окно просмотра)

СОЗДАНИЕ СЦЕН

Вы можете создать так много SceneManagers, как Вам нравится и так много Камер сколько вы хотите, но Вы должны быть осторожными, что, когда Вы фактически хотите рендерить что-то на экране, используя Камеру, Вы должны добавить Viewport для него.

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

Найдите функцию BasicTutorial6::go и добавьте в нее код:

Мы должны включить OgreEntity в код, чтобы компилировать безошибочнр, так что добавьте эту строку к верху 'BasicTutorial6.cpp':

ЦИКЛ РЕНДЕРИНГА - БРАТЬ ОДИН

Чтобы восхищаться нашей работой до сих пор, мы должны сделать рендеринг нашей сцены.

Ogre::Root особенность несколько методов, чтобы начать рендерить цикл, самым простым из которых является Ogre::Root::renderOneFrame().

Это в основном циклы до функции в ложных возвращениях цикла.

Вот то, как это выглядит:

Мы не будем проникать в неприукрашенные детали той функции, только указывать на функцию renderOneFrame.

Мы кратко посмотрели на эту функцию в Основной Обучающей программе 4, но давайте рассмотрим это снова:

Помимо обновления всех объектов рендеринга, она вызывает функции событий фрейма, и если любая из них вернет ложное значение, это вызовет выход из цикла.

Поскольку мы до сих пор не использовали экземпляров FrameListener, нам нужен альтернативный цикл рендеринга.

Добавьте эту линию в список подключаемых заголовочных файлов вверх нашего файла BasicTutorial6.cpp:

Поместите это в BasicTutorial6::go функцию:

Цикл будет проходить снова и снова, до тех пор пока ни закроется окно, и функция renderOneFrame вернет ложное значение

Скомпилируйте и запустите приложение.

Вы должны видеть окно и голову огра в нем.

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

OIS

Хотя это и не единственный вариант для ввода в OGRE, OIS - один из лучших.

Мы кратко рассмотрим как к OIS запускается в Вашем приложении.

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

Расположите следующие директивы подключения заголовочных файлов в файл BasicTutorial6.h:

Добавьте следующих участников данных к классу BasicTutorial6:

Теперь нужно добавить OIS в настройки нашего проекта:

директория библиотеки должна быть уже настроена.

Убедитесь, что после добавления OIS в проект, можете его скомпилировать.

ДОБАВЛЕНИЕ OIS

Ois использует главный модуль InputManager который представляет некоторые затруднения при устновке, но его легко использовать, когда он правильно его создадите.

OIS не интегрируется в Ogre; это - автономная библиотека, что означает, что Вы должны будете предоставить ему некоторую информацию вначале, чтобы он работал должным образом.

Практически это действительно только нуждается в идентификоторе окна, в которое рендерит Ogre.

К счастью, так как мы использовали автоматически созданное окно, Ogre делает это нетрудным для нас.

перейдите в BasicTutorial6::go функция и добавьте этот код перед нашим циклом рендеринга:

Это настраивает InputManager для использования, но фактически чтобы использовать OIS, для получения данных Клавиатуры, Мыши, или Джойстика по Вашему выбору, Вы должны будете создать эти объекты:

Мы передаем 'false' к функции createInputObject, потому что мы хотим иметь мышь и небуферизированную клавиатуру.

заметьте: Если Вы хотите использовать буферизованный вход (значение, что Вы получаете обратные вызовы событий к mouseMoved, mousePressed, keyReleased, и так далее), то Вы должны установить вторые параметры к createInputObject, чтобы быть корректными.

ОТКЛЮЧЕНИЕ OIS

OIS немного сложный, чтобы отключаться правильно.

Самый безопасный способ сделать это - использовать WindowEventListener.

Во-первых, поместите эту строку в свой список включений (includes) в BasicTutorial6.h:

Тогда мы должны изменить объявление класса, чтобы извлечь из WindowEventListener:

Мы хотим отменить WindowEventListener::windowResized и WindowEventListener::windowClosed, таким образом поместить это в защищенный раздел объявления класса BasicTutorial6:

Откройте BasicTutorial6.cpp и добавьте в него следующее:

windowResized вызывают всякий раз, когда окно изменило размеры, и удостоверяется, что положение мыши OIS синхронизировано с текущей величиной окна

windowClosed ликвидирует OIS, когда окно закрывается.

Чтобы заставить наше приложение действовать как WindowEventListener, мы должны зарегистрировать это как один.

Так что добавьте эти строки к BasicTutorial6::go:

Есть еще одна вещь, которую мы должны сделать.

Найдите деструктор BasicTutorial6 и заставьте его быть похожим на это:

УСТАНОВКА FRAMELISTENER

Независимо от того, если Вы используете буферизованный или небуферизированный вход, каждый фрейм, который Вы должны назвать методом захвата на всей Клавиатуре, Мыши, и Джойстик объекты что Вы используете.

Для небуферизированного входа это - все, что Вы должны сделать.

Каждый фрейм Вы можете вызвать различными функциями Клавиатуры и Мыши, чтобы запросить положение этих объектов.

Так, мы должны заставить наш класс BasicTutorial6 стать FrameListener.

Измените объявление класса, чтобы оно выглядело как это:

Тогда добавьте эту функцию объявления к защищенному разделу объявления класса:

И затем, в BasicTutorial6.cpp, добавте это определение функции:

ПОСЛЕДНИЕ ШТРИХИ

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

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

Найдите BasicTutorial6::go и удалите цикл while.

Потом добавьте туда это:

Первая линия кода добавляет BasicTutorial6, в корень как FrameListener, означает, что это получит события фрейма.

Если мы не регистрируем как FrameListener вместе с Ogre::Root frameRenderingQueued функция не будет вызвана.

На второй строке кода начинается цикл рендринга.

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

Скомпилируйте и запустите!

Вы должны видеть фирменную голову огра и приложение должно закрываться при нажатии на клавишу "Esc".

ОПЕРАЦИОННАЯ СИСТЕМА MAC OS X

ВЕРСИЯ COCOA

Новый путь к установке текущей структура обучающей программы wiki для xcode в Mac OS X намного короче и легче понять.

Удостоверьтесь, что Ваш проект создан как применение cocoa и изменил расширение на .mm от.cpp, и скопируйте и ресурсы и плагины cfg к Вашей стадии ресурса копии в Вашей цели xcode.

Теперь измените последовательность:

CARBON ВЕРСИЯ

Так как Mac OS X использует app bundles, концепция радикально отличается от той что мы используем для windows и linux. Код описанный выше не запустится на Mac OS X.

Переведено на Нотабеноиде
http://notabenoid.org/book/19615/64004

Переводчики: cin, ghostintheshell, proVIDec, wuffur

alexx_x