Программирование игр на Adobe Flash 11 Stage3D

Программирование игр на Adobe Flash 11 Stage3D(Molehill) ::: Часть 1

Программирование игр на Adobe Flash 11 Stage3D (Molehill)
Создание игры шаг за шагом на AS3, используя Adobe Flash 11 Stage3D (Molehill) и AGAL

Рис 1.0 Title

Об Авторе
Кристер Kaйтила, B.Sc., является ветераном в разработке видео игр, с 17-летним опытом. Являясь хардкорным геймером, папой, мастером Dungeons & Dragons, художником и музыкантом, он никогда не относится к себе слишком серьезно и любит то, что он делает: создавать игры! Будучи еще новичком на аркадной сцене, он писал свои первые видео-игры еще в восьмидесятых годах, задолго до появления Интернета и жестких дисков.

Первый язык программирования, которому он обучился, являлся 6809 ассемблерный язык, затем он писал код на BASIC, Turbo Pascal, VB, C++, Lingo, PHP, Javascript, и, наконец, на ActionScript. Он был элитным сисопом BBS в эру популярности MS-DOS и был активным членом демо-сцены в подростковом возрасте. В университете он подрабатывал, писав программное обеспечения для клиентов. Он был активным членом сообщества развития инди-игр и известен своим собратьям-инди, как брейкдансер McFunkypants.

Кристер часто присоединяется к IGJ, чтобы сохранить свое мастерство, всегда рад помочь людям, с их проектами, и играет важную роль, помогая найти ошибки в продуктах Adobe, которые еще не были обнародованы. На протяжении многих лет, он писал игры-головоломки, мультиплеерные RPG, экшены, стрелялки, гонки, чаты, онлайн-миры, браузерные игры, бизнес приложения для клиентов, для промышленных устройств, и для инженеров.

Он является куратором популярного новостного сайта, который называется www.videogamecoder.com, там всегда выкладываются свежие новости от других разработчиков игр. Он рад поболтать с вами на twitter (www.twitter.com/McFunkypants) или Google+ (www.mcfunkypants.com/+) и всегда рад помочь вам со своими друзьями разработчиками игр.

Его портфолио доступно на www.orangeview.net и у него есть его личный блог www.mcfunkypants.com , где вы можете прочитать больше о инди-игровом сообществе и о его последних проектах.

Он живет в Виктории, Канаде, с любимой женой и самым красивым младенцем-сыном.

Предисловие
Adobe Stage3D (ранее известный под именем Molehill) -это набор 3D API, которые принесли 3D на Flash платформу. Будучи совершенно новой технологией, по ней еще практически нет документации, чтобы вы могли бы ознакомится с этой революционной технологией уже сейчас.

Эта книга покажет вам, как делать свои собственные некстген 3D игры во Flash. Если вы всегда мечтали написать собственную 3D игру на Flash, готовьтесь, чтобы не быть сдутым силой аппаратного ускорения Stage3D. Эта книга проведет вас шаг за шагом через процесс программирования 3D игры на ActionScript 3, используя эту захватывающую технологию. Наполненная примерами, рисунками, и исходными кодами, вы пройдете необходимую практику и вы получите удовольствие от ее прочтения. Эта книга будет способствовать обучению написания 3D-игр как для начинающих, так и для уже опытных разработчиков игр.

Начиная с простых задач, таких отрисовка простой 3D фигуры в Flash, каждая глава представляет более глубокое и полное понимание процесса написание видеоигр, используя в качестве примера, реальный проект. Отталкиваясь от простой технической демки, ваша игра будет постепенно набирать вес, в результате превратившись в законченный продукт – ваша 3D игра наполнится анимацией, спецэффектами, звуком и экшеном. Цель этой книги состоит в том, чтобы научить вас написанию полноценной игры на Stage3D, от начала и до конца.

Выполняя этот эпический квест, вы узнаете всякие полезные приемы, такие как создание привлекательных спецэффектов с использованием текстур, специальные режимы смешивания для реализации прозрачной системы частиц, фантастические вершинные и пиксельные программы, используемые для создания потрясающих шейдеров, и многое другое. Вы узнаете, как загрузить геометрию ваших 3D моделей в память видеокарты для ультра-быстрого рендеринга. Вы окунетесь в волшебный мир искусства программирования шейдеров на AGAL. Вы узнаете, трюки оптимизации вашей игры, чтобы добиться молниеносной частоты кадров даже при полноэкранном разрешении. В каждой главе, вы будете поднимать свой уровень навыков программирования, заслуживая звание называться мастером Molehill – вы сможете честно называть себя программистом 3D игр.

Эта книга написана для начинающих ветераном в программирования игр. Эта книга станет вашим верным товарищем, заработав необходимые знания, вы сможте сделать вашу собственную 3D-игру на Flash.

Что охватывает эта книга
Глава 1. Давайте делать игры на Molehill! В этой главе мы поговорим о том, что такое Stage3D (Molehill) , что он может делать, и изучим основную терминологию, которую вам нужно будет знать при написании 3D-игр.

Глава 2. Проект Molehill. В этой главе мы выявим различия между старомодными Flash играми и новым способом написания игр, познакомимся с основными классами с которыми мы будем работать и типичной структурой Stage3D игр.

Глава 3. Запускаем Двигатели! В этой главе, мы сделаем первый шаг по настройке нашего инструментария и напишем основной код для нашей игры. В результате мы напишем демку, которая будет использовать Stage3D для отрисовки и простой анимации 3D меша.

Глава 4. Основы шейдеров: Я могу видеть это! В этой главе мы узнаем все о программировании шейдеров, написанных на AGAL и о добавлении текста на экран. В результате мы получим обновленную демку – с четырьмя различно анимированными шейдерами.

Глава 5. Создаем 3D мир. В этой главе, мы узнаем способ наполнения нашего 3D мира игры сложными 3D моделями, о процессе, называемым парсингом моделей. В результате мы получим демо-версию игры с высоко-полигональными космическими кораблями и рельефом местности, а не просто квадраты с текстурой.

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

Глава 7. Таймеры, пользовательский ввод и сущности: Его величество геймплей! В этой главе мы напишем таймер и общий класс для сущностей игры. Кроме того, мы улучшим GUI нашего пользовательского интерфейса и добавим выбор камеры. В результате получим демо с кораблем, который может летать рядом с астероидами. Это уже будет больше похоже на реальную видеоигру.

Глава 8. Система частиц! В этой главе мы напишем хорошо GPU оптимизированную систему частиц для создания различных спецэффектов. Все геометрия будет визуализироваться в больших, многоразовых пакетах. В результате мы получим демоверсию игры,которая сможет рендерить сотни тысяч частиц при 60 fps.

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

Глава 10. 3… 2… 1… МОТОР! ! ! В этой главе мы добавим последние штрихи к нашей игре, например, такие как заставочный экран, очки игрока, здоровье игрока и события игры, музыку,звук и многое другое. Конечным результатом наших усилий будет полностью законченный 3D-шутер, наполненный экшеном!

Что вам требуется для работы с книгой
Рекомендуется: FlashDevelop 4 (доступный для свободного скачивания с http://www.flashdevelop.org) или Adobe Flash CS5 (или новее).

Код в книге можно скомпилировать и в любой другой AS3 среде програмирования, такой как FlashBuilder, FDT, или в Flex, лишь внеся совсем незначительные изменения.

Дополнительный инструментарий:
‹ Программное обеспечение для редактирования изображений (Photoshop, GIMP и т.д.)
‹ Программное обеспечение для 3D моделирования (3ds Max, Maya, Blender, и т.д.)

Для кого эта книга
Если вы когда-нибудь хотели делать свои собственные 3D-игры на Flash, то эта книга для вас. Эта книга является идеальным введением в 3D игры, в программирование игр с использованием Adobe Molehill.

Вам не нужно ничего знать заранее о Stage3D/Molehill или о Flash 11 для того, чтобы понять примеры из этой книги. Весь необходимый материал будет описан в ней. Но эта книга предполагает, что вы все же имеете некоторый опыт программирования на AS3 (ActionScript 3).

Содержание:
1. Давайте делать игры на Molehill!
Вас ждет эпическое приключение!
Что такое Molehill?
Что Molehill не может.
Что нужно знать уже
3D терминология
Общие термины касаемые 3D-контента.
Mesh
Полигон
Вершина
Текстуры
Шейдеры
Вершинная программа
Фрагментная программа
Ачивмент «3D-контент» получен!
Термины 3D программирования
Векторы
Нормали
Матрицы
Ачивмент «3D-кодинг» получен!
Резюме
Уровень 1 достигнут!

2. Проект Molehill.
Старомодный способ
Molehill: Stage3D
Использование 2D флеш текста и спрайтов
Почему Stage3D работает так быстро?
Структура Molehill приложения
Stage
Stage3D
Context3D
VertexBuffer3D
IndexBuffer3D
Program3D
Схема последовательности выполнения операций программ Molehill
Время для действий – что мы должны сделать один раз, в процессе настройки игры
Время для действий – что мы должны делать снова и снова
Резюме
Уровень 2 достигнут!

3. Запускаем Двигатели!
Шаг 1: Загрузка Flash 11 (Molehill)
Время для действий – получаем плагин
Время для действий – настраиваем профиль Flash 11 в CS5
Время для действий – обновляем Flex
Время для действий – обновляем файл playerglobal.swc в Flex
Время для действий – компилируем код в Flex используя параметр SWF Version 13
Время для действий – обновляем шаблон HTML файла
Stage3D теперь настроена!
Шаг 2: Приступаем к написанию кода.
Время для действий – создаем пустой проект
Время для действий – импорт классов для работы с Stage3D
Время для действий – инициализация Molehill
Время для действий – определение некоторых переменных
Время для действий – добавление текстуры
Время для действий – определение геометрии вашего меша
Время для действий – запускаем движок
Время для действий – добавляем еще кода в функцию onContext3DCreate
Время для действий – загружаем наши данные
Время для действий – настраиваем камеру
Время для действий – добавим анимацию
Время для действий – настраиваем цикл рендеринга и отрисовку нашего меша
Квест выполнен – время пожинать плоды
Поздравляем!!!
Исходный код
Резюме
Уровень 3 достигнут!

1. Давайте делать игры на Molehill!
Добро пожаловать, отважный герой!
Вы собираетесь выполнить поистине эпический квест: сделать игру, используя Stage3D API (Molehill). Этот квест будет полон радости и волнения, но также и проблем и неудач. Но есть одна вещь, которая вам обязательно понравится. Программирование 3D игр – это не просто – но вы все равно СМОЖЕТЕ научиться этому!

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

Эта книга будет задавать тон великой приключенческой истории. Мы будем исследовать Molehill вместе, преодолевая трудности и медленно накапливая наобходимые знания. С каждым шагом, пройденным по пути к нашей цели – создания 3D игры, вы будете зарабатывать «очки опыта». Во время вашего путешествия, по процессу созданию игры, вам будут ставиться определенные задания, которые мы будем называть «квесты». В конце каждой главы, когды вы решите все эти квесты, вы будете поднимать свой текущий уровень («level up»).

Эта книга написана для абсолютных новичков в Molehill, и пытается быть неформальной, веселой, легкомысленный, такой которую интересно читать. Я не хочу, просто скучно перечислять каждую Stage3D команду по порядку. Эту информацию можно найти с помощью Google.

Вместо этого, мы начнем с нуля и постепенно будем исследовать мир 3D Flash все глубже и глубже, постоянно получая необходимые навыки. Примеры в книге насыщенны информацией, и вы можете использовать их в своих играх, которые используют Flash 11 Stage3D API.

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

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

Так что давайте начнем! Выделим время для тренировочного лагеря, потому-что любое приключение начинается – с ознакомления с базовыми правилами игры . Основы:

Что такое Molehill?
Molehill- это кодовое имя новейшей Flash технологии от Adobe - «Stage3D». Она была специально разработанна для использования современного аппаратного ускорения видеокарт. Просто игры, которые можно увидеть на консолях, таких как XBOX 360 и Playstation 3, обладают такой чудесной графикой благодаря аппаратному ускорению 3D-графики графическими процессорами.

Сравните это с тем, как Flash традиционно формирует изображение на экране: векторная графика растеризуется программным обеспечением в 2D изображения и рисуются на экране пикселями. Как результат -вычисления обходятся очень дорого для CPU и выполняются крайне медленно. Если вы когда-нибудь экспериментировали с рисованием нескольких сотен спрайтов в Flash, вы знаете, что в этом случае Flash начинает работать очень медленно, до такой степени, что становится невозможно сделать что-либо.

С другой стороны, при использовании Molehill, вся обработка пикселей ложится на плечи видеокарты, освобождая ресурсы CPU вашего компьютера, для того чтобы он делал другие вещи, в то время как 3D графика, растеризуется в GPU (графический процессор) вашей видеокарты. Это позволяет создавать новые флэш-игры, написание которых было невозможно ранее, которые могут отрисовывать сотни тысяч спрайтов на экране в полноэкранном режиме, при минимальной загрузке CPU.

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

Бенчмарки показали, что растеризация 3D сцены состоящей из более 150 000 полигонов в полноэкранном режиме в HD-разрешении, происходит при 60 кадров в секунду (FPS) с загрузкой CPU менее чем на 10%. Сравните этот показатель с старомодной Flash-анимацией, при использовании которой CPU может лечь при попытки отрисовать всего лишь несколько тысяч эльфов в маленьком окне.

Используя Stage3D API, могут вздохнуть свободно и художники и дизайнеры игры, у них станет больше времени думать о содержании игры и меньше беспокоится о производительности. Вы сможете рисовать сотни взрывов, частицы дыма и специальные эффекты в огромных и сложных 3D мирах, где при перемещении на транспортных средствах, в зданиях и по местности, по-прежнему будет поддерживаться феноменальная частота кадров в секунду.

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

Что Molehill не может.
Molehill – это очень низкоуровневое API. Оно содержит только основную функциональность для осуществления 3D визуализации . Это безумно быстрая технология, и блестящие умы Adobe приняли верное решение, сделав все как можно более минималистичней. Molehill делает только одну вещь и делает это хорошо. Он не пухнет от функций. Это не джек-на-все-руки, с миллионом функций. Это низкоуровневый интерфейс программирования, который создан исключительно для 3D-рендеринга и для ничего больше.

Это не графический 3D движок (как например, Unity3d или Unreal, или ID Tech). Игровой движок как правило включает в себя вспомогательные модули, используемые при создании игры, такие как моделирование физики, работа со звуком, музыкой, систему обнаружения столкновений, и многое другое. Вместо этого, вы используете низкоуровневое API, такое как Molehill для создания вашего собственного игрового движка с нуля.

Вместо того, чтобы быть всем для всего, Molehill выполняет только одну функцию, визуализацию 3D графики, и делает это действительно хорошо. Так же как OpenGL или Direct3D, Molehill-это сборник самых основных функций. Они являются основными строительными блоками для любых игр и игровых движков.

Мы будем программировать на Molehill, используя новый набор AS3 команд. Низкоуровневый код (для шейдеров) пишется на своем собственном языке, который компилируется и загружается в видеокарту. Шейдерный язык Molehill поразительно похож на самый низкоуровневый язык программирования, ассемблер.

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

Что нужно знать уже.
Чем дольше вы находитесь с Flash, ActionScript, тем легче вам будет усваивать поданную мной информацию. Но вам не нужно знать ничего о Molehill. Всю необходимую информацию о нем вы почерпнете из этой книги. Новички также приветствуются.

Как вы знаете, AS3 (сокращение для Flash ActionScript 3) – это язык программирования, который является очень похожим на Javascript и C++. Вы уже должны быть знакомы с Flash-программированием, но вы не обязательно должны быть 3D-экспертом.

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

Если вас не устраивают ваши знания AS3, это не проблема! Есть много-премного доступных книг, которые смогут помочь вам с AS3. Дойдите до уровня, при котором вы сможете запрограммировать простое «Привет, мир!» в вашем Flash приложении, а потом возвращайтесь обратно. Обучение базовым навыкам программирования выходит за рамки этой книги, которая является лишь книжкой о Molehill.

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

3D терминология
Ваша базовая подготовка, чтобы добраться до «первого уровня», должна включать в себя знания некоторой предварительной терминологии, которую вы обязательно встретите во время своего приключения по написанию 3D игры. Большинство из них являются обобщенными понятиями, относящимися конкретно к 3D.

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

Готовы ли вы использовать оба вашего полушария головного мозга? Нам нужно идти по двум группам терминов: 3D графика и 3D-кодинг.

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

Ваша логическая сторона, левая сторона вашего мозга, ищет все, что связано с алгоритмами. Она хочет писать какой-нибудь вкусный код и смотреть что в результате из этого получается. Работая вместе, искусство и код используется для создания видеоигр. Ниже приведены основные определения, которые вам нужно знать для того, чтобы продвинуться вперед и окунуться в мир Molehill.

Общие термины касаемые 3D-контента.
Эта часть книги является отличным кормом для правой стороны вашего мозга. Да это касается искусства.

В 3D играх вы видете, что в виртуальном мире моделируется глубина и объем. В отличие от 2D игр, где вы только видете на экране различные плоские изображения, в 3D-играх вы можете «заглянуть за угол» , объекты находятся как и в реальном мире, в трех измерениях. Для того, чтобы это реализовать, чаще всего используются следующие составляющие.

Mesh
Модель в 3D-игре, как правило, называется мешем. Меш строится в пакетах приложений для 3D-моделирования таких как Maya, 3D Studio Max, или Blender. Меш определяет 3D форму объекта, а также цвета, используемые для его визуализации. Ваш главный герой игры может состоять из одного(или более) мешей. Транспортное средство, здание, или дерево – каждый объект является индивидуальным мешем. Одна сцена может быть построена из сотен мешей.

Рис 1.1 Mesh

Полигон
Каждая грань меша представляет из себя плоскую геометрическую фигуру. Один меш может быть сделан из сотен или даже тысяч полигонов. Один полигон может являться простым треугольником с тремя ребрами. Это может быть «quad» или квадрат с четырьмя гранями или прямоугольник. Представьте, например, 3D куб. Он состоит из шести различных квадратов (quads), по одному на каждую сторону. Каждый из этих квадратов является полигоном.

Любой полигон может быть построен из коллекции треугольников. Например, quad может быть из двух треугольников, соединеных общей гранью. В результате, современные видеокарты работают с 3D геометрией, как с огромной коллекцией треугольников. Обычно, когда кто-то говорит вам про количество полигонов из которых состоит меш, они имеют в виду, какое количество треугольников используется, для построения этого меша. Когда производители видеокарт хвалятся об своих последних и наилучших показателях, они говорят как много полигонов их видеокарты могут визуализировать и сколько раз в секунду, они могут это сделать.

Вершина
Каждый полигон состоит из трех или более «уголков «. Например, в квадрате quad, есть четыре угла. Каждый из этих четырех углов называется вершиной. Вершины (точка в пространстве, где находится угол полигона) , определяется как простая точка в 3D мире.

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

Рис 1.2 Вершина

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

Текстуры
Для того, чтобы визуализировать меш (если вы не хотите, конечно-же, визуализировать меш в wireframe режиме), вы будете использовать одно или больше изображений, которые называются текстурами, цветом шейпа. Текстуры можно рассматривать как обои: наклеивая текстуры на меш, обматывая ими меш, мы в результате получаем раскрашенный меш. Например, представьте куб. Он имеет шесть сторон, определенных в общей сложности восемью вершинами (по одной на каждый угол). Для того, чтобы сделать куб видимым и чтобы он выглядел как будто бы сделанный из ржавого металла, вы можете нарисовать, используя Photoshop или GIMP, изображение и сохранить его в формате .jpg или .png. Эта картинка будет вашей текстурой. Сказав Molehill обернуть меш этой текстурой, вы получите в вашей игре ржавый металлический куб.

Шейдеры
Шейдеры определяют визуальный стиль игры. Они определяют «как рисовать» что-либо. Один шейдер может быть использован для рисования блестящего металла, а другой может быть использован для рисования взрывов.

В Stage3D API, шейдеры хранятся в классе Program3D. Для того, чтобы создать шейдер, вы
должны создать «фрагментную программу» и «вершинную программу». Сочетание этих двух программ и будет шейдером.

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

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

Вершинная программа, скажет вашей фрагментной программе о текущем состоянии каждой вершины вашего меша.

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

Рис 1.3 Вершинная программа

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

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

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

Фрагментная программа
В Molehill, фрагментная программа – это набор команд, которые определяют, как визуализировать конкретный меш. Иногда такие программы еще называют пиксельными шейдерами, фрагментная программа содержит все данные, о том как данные поверхности и текстуры должны реагировать на свет. Различные материалы могут реагировать на свет по-разному (в зависимости от того, являются ли они отражающими или прозрачными или еще какими-либо), и вам нужно писать некоторый код для симуляции этого.

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

Рис 1.4 Фрагментная программа

Используя фрагментные программы, вы можете добавить специальные эффекты к вашей обычной текстуре, такие как добавление бликов или тени, или анимацию в реальном времени. Фрагментные программы позволяют вам растворять вершины, изменять оттенки различных цветов, и говорят вашей видеокарте, как визуализировать каждый полигон меша. Каждый меш визуализирует фрагментная программа, без ее участия ничего не рисуется. Это может быть простая фрагментная программа (просто использует текстуры как есть) или сложная (смешивает две текстуры вместе и придает им полупрозрачный блестящий ярко-красный оттенок, зависящий от положения источников света).

Ачивмент «3D-контент» получен!
Мы познакомились со всем что касается графического 3D контента, необходимого нам при написании игры! Все что вам нужно помнить, это то, что для каждого объекта, который вы хотите визуализировать на экране, вы должны загрузить некоторые данные в вашу видеокарту.

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

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

Вы контролируете все, что необходимо для получения эффектной 3D-графики. Я думаю, у вас есть идеи как использовать эту графическую мощь. Все, что вы видите в сегодняшних некстген играх, может быть сделано на Molehill, с помощью фрагментных и вершинных программ. Возможности безграничны.

Термины 3D программирования
Данный раздел предназначен для левой стороны вашего мозга. Здесь написано обо всем что касается написания кода игры.

Видеоигры-как зелье. Вы берете сырье (арт-контент) и добавляете немного магии. Некоторое количество 3D-кода, это все, что требуется, чтобы волшебство создания игры произошло.

Не бойтесь написания кода, как программист, вы знаете, как это делается. Изучив следующие понятия, у вас появятся инструменты, для того чтобы заставить вещи двигаться вокруг вас. К счастью, вам не нужно быть вундеркинд-математиком для того чтобы сделать игру. Даже если вы в первую очередь художник, вы можете написать игру с помощью Molehill учась на примерах.

Вместо изучения подробного списка всех возможных 3D функций во Flash, содержащихся в гигантском, покрытым пылью томе, наполненным тригонометрией и продвинутыми вычислениями, вам необходимо знать только четыре термина описанных ниже. Если есть желание, вы всегда сможете найти с помощью Google дополнительную документацию по 3D,Flash, AS3.

Хорошей новостью является то, что 90% времени, вы будете работать только со следующими структурами данных: вектором, нормалью и матрицей.

Векторы
Vector3D – это объект, который содержит значения x, y, и z, которые описывают точку в 3D-пространстве.

Каждый компонент вектора представляет собой число (которое может быть положительным или отрицательным, или может быть дробью), и каждое число вектора это расстояние от 0,0,0 (начало координат). В 2D Flash, Point(0,0), как правило, определяет верхний левый угол сцены, в 3D же Vector3D(0,0,0) будет представлять местоположение «центра вселенной» или середину 3D-мира. Эта позиция (0,0,0) называется началом координат. Термин, используемый для описания x, y или z части вектора, называется осью.

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

Рис 1.5 Векторы

Например, ось x (первое число в Vector3D) , как правило, представляет собой движение влево-вправо. Ось y – наиболее часто используется для движения вверх-вниз, а ось z описывает ближе-дальше движения (то есть, двигаясь ближе к камере, или дальше от камеры). В 3D сцене, когда увеличивается z координата объекта, видно как он становится меньше, так как он движется от камеры. У векторов на самом деле есть четвертый компонент, w, но он редко используется. Его удобно использовать для хранения значения поворота. В подавляющем большинстве случаев, вы будете рассматривать Vector3D как состоящий только из x,y,z.

Представьте себе, что вы хотите разместить модель дерева в конкретном месте на 3D сцене. В старомодных 2D флеш играх, вы, скорее всего, использовали бы класс Point, который имеет x и y координаты, для того чтобы описать, где на экране должен отрисовываться спрайт. В Molehill, вам нужно будет работать с классом имеющим имя Vector3D.

Вот некоторые примеры того, как можно использовать векторы в Molehill:

import flash.geom.Vector3D;
var putTheTreeHere:Vector3D = new Vector3D(0,0,0);
var locationOfTreasure:Vector3D = new Vector3D(1000,0,-15000);
var aNormalPointingUp:Vector3D = new Vector3D(0,1,0);

Вы, наверное, уже догадываетесь, что делает каждая строчка из предыдущего кода. Мы объявили три переменные. Каждая из них это вектор, и может быть использована, чтобы описать где находится что-то в мире. Класс Vector3D находится в пакете flash.geom.

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

trace(locationOfTreasure.z);

После запуска приложения в окне отладки будет выведено число -15000, которое является z-компонентой переменной locationOfTreasure.

Нормали
Есть специального рода вектор, который обычно используется для описания направления, вместо местоположения. Такой вектор называют нормалью. Вы можете описать его, используя тот же класс, Vector3D. Только разница между позиционным вектором, который может выглядеть как [55,5000,12] и направленным вектором, нормалью, заключается в том, что нормали всегда имеют длину равную 1 .

Нормали также часто называют «единичными» векторами, потому что они имеют длину равную одной единице. Термин «нормаль» , буквально означает – перпендикулярный (например, нормаль к плоскости, или направленный прямо от конкретной поверхности). Например, вектор нормали, который описывает направление вверх будет [0,1,0] (при условии, что ось y направлена вверх в этом мире, то этот вектор описывает направление, перпендикулярное «земле»).

В предыдущем примере кода, в переменную с именем aNormalPointingUp записывается Vector3D, имеющий длину равную 1.

Причина, почему нормали настолько удобны, является то, что поскольку они имеют длину равную 1, то вы можете использовать их для описания скорости перемещения или растояния. Например, если вы умножите нормаль, которая направлена вверх на число, например, 100, то в результате длина вектора станет равна 100 единиц по оси y.

Вы можете складывать векторы вместе, вычитать, умножать, и делить их. В каждом из этих случаев, происходит вот что: каждая компонента вектора (x,y,z) добавляется или вычитается, или умножается на соответствующие компоненты второго вектора.

Как бы мы это сделали? Ну, мы могли бы добавить вектор NormalPointingUp из предыдущего примера, в вектор locationOfTreasure:

locationOfTreasure = locationOfTreasure.add(aNormalPointingUp);
trace(locationOfTreasure.y);

В результате в окне отладки была бы выведена цифра 1.

Это могло бы привести к такому результату, при котором сокровище переместилось бы на 1 по оси Y. То есть сокровище теперь бы плавало над землей.

В примере выше, у нас было первоначальное значение locationOfTreasure (1000,0,-15000) и после добавления к нему aNormalPointingUp, новое значение стало (1000,1,-15000). Это понятно, не так ли?

Переменная aNormalPointingUp – это особый вектор. Так как он имеет длину равную 1, то он называется нормализованным вектором, или просто «нормалью». Зачем делать различие между вектором и нормалью? Нормаль, ведь это просто особый вид вектора. Так как она имеет длину равную 1, то вы можете использовать эту особенность различными способами, например, умножив ее на количество времени, которое прошло с последнего кадра, для того чтобы ракета летела с определенной скоростью.

Вы можете превратить позиционной вектор, например, [55,5000,12], в нормаль, путем деления значения длины каждой оси вектора на общую длину вектора, в результате этого, общая длина вектора станет равна 1. Самый простой способ выполнить это, состоит в использовании функции normalize(), которая находится в классе Vector3D.

Зачем вам это может понадобится? Возможно, вы захотите знать направление «точки» к какой-то особой локации. Например, нормалью вектора [55,5000,12] будет являться, приблизительно, нормаль [0.011,0.987, 0.002]. Вы можете видеть, что пропорции каждой оси в векторе сохранились, просто теперь их общая длина уменьшилась до единицы.

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

Матрицы
Иногда вам будет необходимо двигать,вращать и масштабировать объекты, за одно дыхание. Для того, чтобы сделать вашу жизнь проще, существует еще один AS3 класс, который можно будет использовать. Matrix3D – это просто набор векторов. Векторы внутри матрицы описывают положение, поворот и масштаб. Часто, вам будет необходимо что-то двигать и в то же время вращать это, а возможно, даже увеличивая размер. Класс Matrix3D использует 4×4 квадратную матрицу: четыре строчки и столбцов цифр, которые содержат данные необходимые для трансформации объекта.

Вам не нужно знать, как организована матрица. Вам просто нужно знать, что она очень полезна, как способ, для того чтобы сразу описать положение, вращение и масштабирование 3D-объекта, так, что вы сможете применить все эти трансформации к объекту всего одной строчкой кода. Есть много полезных функций в классе Matrix3D, которые могут выполнить всю трудную работу за вас, такую, как изменение масштаба, углов поворота или перемещение объекта.

Например, представьте себе дым, который использует потрясающую систему частиц, для взрыва.
В каждом кадре, эти частицы нужно будет поднимать в воздух, вращать их, и возможно, увеличивать, для достижения эффекта рассеивания дыма. Используя матрицы, вы можете делать все это одной строчкой кода. Как правило, в таких системах частиц этот класс называется Transform, но знайте, что это просто другое название для матрицы, которая используется для описания движения объекта в пространстве. Вы тоже будете создавать матрицы и использовать их для трансформирования (перемещения, масштабирования, поворота, и так далее) объектов. Иногда в 3D-программировании, вы можете встретить термин «матрица трансформации», и это как раз и есть та матрица, о которой мы говорили выше. Например, для трансформации какого-либо вектора, вы можете умножить его на матрицу.

Ачивмент «3D-кодинг» получен!
Это все! Это все термины програмирования, которые вам нужно знать сейчас. Все эти разговоры о 3D матрицах и декартовых координатах могут немножко испугать. Не бойся, доблестный герой.

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

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

1. Представьте себе, 3D модель дома. Координаты x, y, и z вашего 3D дома в игровом мире будет описываться:
а. Матрицей 4×4
b. Текстурой
c. Vector3D
d. Может быть цифрами, на кусочке бумажки?

2. Если вы захотите сделать стены вашего дома, как будто бы покрытыми фиолетовыми клетчатыми обоями, вы можете нарисовать их в предназначенной для этого программе, сохранить их как jpeg, и использовать это изображение в фрагментной программе, как:
а. Нормаль
b. Текстуру
c. Полигон
d. Секретный ингредиент

3. Представьте себе гигантского огра, который нечайно толкнул ваш дом, когда переходил на следующую улицу. Ваш дом из-за этого немножко сдвинулся. Скажем исходное положение дома было [10,0,10]. Огр сдвинул дом на значение: [5,0,0]. Где теперь находится ваш дом?
а. [15,0,10]
b. [15,0,0]
c. [5,0,10]
d. 42

Герой – ваш первый сторонний квест

Для того, чтобы оттачивать свои навыки, можно испытать самого себя, для получения некоторого дополнительного опыта. В конце каждой главы, есть побочный квест-без объяснения решения – он написан для вас, чтобы вы могли поэкспериментировать, но он не является обязательным к выполнению. Также как и в RPG играх, вы выполняете побочные квесты, для того чтобы стать сильнее, для того чтобы когда вам придется продвигаться вперед по основному квесту, вам было бы не так сложно сделать это.

Текущим вашим сторонним квестом, является квест с заданием скомпилировать следующий исходный AS3 код, и настроить ваш испытательный стенд для дальнейших экспериментов.

Если вы любите использовать Flash IDE, то это просто здорово. Просто создайте пустой проект и бросьте этот код, туда куда вы сочтете необходимым. Если вы используете FDT или Flex, то вы наверняка уже знаете, как сделать «hello world» проект.

Многие разработчики игр, в настоящее время используют FlashDevelop в качестве IDE, который использует Flex для компиляции чистых AS3 проектов, которые не используют таймлайн CS5. FlashDevelop абсолютно бесплатен и настоятельно рекомендуется к использованию, как наиболее гибкий, более быстрый способ создания флеш-файлов. Вы можете скачайть его с http://www.flashdevelop.org/. Каким бы ни был ваш выбор, вы должны уметь компилировать as3 проект в этой IDE.

Просто запустите ваш IDE или выбранный редактор кода и посмотрите выводит ли ваше приложение текст «привет мир» когда компилируется. На экране ничего не будет нарисовано: этот листинг кода просто выводит пару строк текста в окно отладки:

package{
import flash.geom.Vector3D;
 
  private var putTheTreeHere:Vector3D = new Vector3D(50,0,5000);
  private var moveItByThisMuch:Vector3D = new Vector3D(0,0,0);
 
  function moveTheTree():void {
    trace('The tree started here: ' + putTheTreeHere);
    putTheTreeHere = putTheTreeHere.add(moveItByThisMuch);
    trace('The tree is now here: ' + putTheTreeHere);
  }
}

Когда вы создаете новый проект, вам возможно, придется удалить код написанный по умолчанию из класса и заменить своим, в зависимости от того, используете ли вы чистый AS3, flex или flash ide. Это ваш выбор, как настроить базовый проект, выберите путь который будет вам наиболее удобным.

После того, как код скомпилируется, ваша следующая часть стороннего квеста(это должно быть легко для вас) , заключается в изменении переменной moveItByThisMuch так, чтобы финальные координаты дерева были [100,0,5555].

Попробуйте поиграть с векторами немного больше. Например, вы можете перемещать дерево, на небольшое расстояние в каждом кадре, по событию EnterFrame. Вы можете придумать способ, который бы перемещал дерево всегда с постоянной скоростью, независимо от величины частоты кадров.
Подсказка: вы можете узнать, сколько ms прошло с предыдущего обновления кадра с помощью функции getTimer(), а затем умножить небольшой вектор на эту сумму и добавить к текущей позиции дерева. Используйте Google, если это вам необходимо. Я знаю, вы сможете сделать это!

Резюме
Мы многому научились в этой главе, мы узнали об общих терминах используемых в 3D-программировании. Хорошей новостью является то, что вы теперь знаете все, что требуется, чтобы написать видео-игру. Всякий раз, когда вам нужно переместить что-то, повернуть, изменить масштаб, или вычислить, как далеко находится какой-то объект от вас, вы будете работать с векторами или матрицами. Несколькими месяцами позже, когда вы будете находится в процессе создания своего неповторимого игрового шедевра, вы скорее всего, будете тратить большую часть своего времени на работу с векторами, нормалями и матрицами. Остальное же время, вы будете работать с визуальной составляющей игры, вы будете думать о полигонах и текстурах.

Мы рассмотрели:
‹ Vector3D: содержащий x, y, и z-компоненты
‹ Нормаль: Vector3D, который имеет длину равную 1
‹ Матрица: 4×4 группа векторов с значениями положения, поворота и масштаба объекта
‹ Вершина: точка в пространстве на углу полигона
‹ Полигон: шейп, который определяется несколькими вершинами
‹ Меш: группа полигонов, которые и формируют облик модели
‹ Текстуры: растровое изображение, которое используется в качестве обоев меша
‹ Шейдер: программа, которая включает в себя вершинную и фрагментную программы
‹ Вершинные программы: команды, которые влияют на форму меша
‹ Фрагментные программы: команды, которые влияют на визуализацию меша
Теперь, когда мы изучили основы 3D-программирования, мы готовы окунуться с головой в Molehill. Мы сейчас вооружились достаточными знаниями, чтобы перейти к следующему уровню.

Уровень 1 достигнут!
Поздравляем! ! ! В качестве бонуса к первому уровню, для вас открылась дверь, которая ведет в внутренние секреты Stage3D API, которые и являются темой нашей следующей главы.

2. Проект Molehill.
Вот мы и перешли на второй уровень!
Теперь, когда вы изучили основную терминологию, пришло время, начать выполнять основной квест этого захватывающего приключения. В этой главе мы узнаем о структуре приложения использующего Molehill. Что, куда и зачем? Как это все соединить вместе? Что это за «Stage3D» о которой мы постоянно слышим?

Графика Flash 11 невероятно быстрая. Как я уже писал в первой главе, причина того, что она работает так эффективно, заключается в том, что Adobe приняла интеллектуальные решения, для того чтобы заставить вашу видеокарту, делать всю грязную работу. Но Molehill не работает по тем же принципам, к которым вы привыкли. Если вы знакомы с 2D флеш-программированием на AS3, то вы будете чувствовать себя, как будто вы изучаете чужую и незнакомую землю. Но это изучение неизвестного является интересным и новым. Поэтому, запускайте свой приключенческий механизм и давайте двинемся в путь!

Старомодный способ
Представьте себе средневековый мир, в котором все бои происходят на традиционных видах оружия, таких, как мечи. Это похоже на предыдущие версии Flash, где все делается без аппаратного 3D ускорения. Вдруг, вы научились применять магию. Это меняет все. Это похоже на изобретение Molehill.

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

Вам по-прежнему нужны ваши старые знания – Molehill не заменяет Flash – он просто добавляет новые возможности.

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

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

Этот старый подход к отрисовке, является причиной того, почему в Flash играх вы не можете разместить очень много фигур на экране, без ушерба для частоты кадров. Из-за этого вы также не можете наложить слишком много полупрозрачных объектов, друг на друга, потому-что ваша игра превратится в слайд-шоу.

Это является причиной того, для чего был создан Molehill: играм нужна стабильная частота кадров! Используя старый способ реализовать это было бы невозможно.

Molehill: Stage3D
Игры, которые используют Stage3D снимают с CPU всю тяжелую-неэффективную работу, которую ему приходилось делать раньше. Вместо того, чтобы быть частью стандартного флеш списка отображения, вместо того, чтобы пытаться старыми метода сделать какие-то вещи, Molehill игры имеют прямой доступ к видеопамяти. Вместо того, чтобы подсчитывать сначала пиксели в RAM, после чего копировать эти значения на экран, Stage3D поступает по другому, она пишет данные непосредственно в видеопамять за один проход.

Stage3D использует DirectX 9 на машинах с Windows и OpenGL 1.3 на Mac OS-X и Linux. На мобильных устройствах, таких как планшетные компьютеры, телевизоры, телефоны, Stage3D использует OpenGL ES2. Для устройств, которые не поддерживают ни один из этих трех интерфейсов, Flash использует очень быстрый CPU-растеризатор с именем SwiftShader.

Выбрав быструю технологию, которая будет работать на любой платформе, Stage3D также был создан для того, чтобы работать на любом устройстве. Эти устройства могут быть и супер мощными игровыми машинами со всяким новейшим железом и новейшими драйверами, но также могут быть компьютером вашей бабушки, которая сдувает пыль с него только чтобы отправить e-mail. Так как существует резервный режим (SwiftShader), вы можете быть уверены, что ваши игры будут работать даже на компьютерах, которые не имеют GPU (3D видеокарты).

Хорошей новостью является то, что вам не придется беспокоиться о том, что происходит в Stage3D под капотом. Не имеет значения, работаете ли вы в Windows, OS, Android или iOS. На ПК, телефоне, телевизоре, на всем этом Stage3D будет работать. Вам никогда не придется выбирать разные API, например для OpenGL или DirectX. Stage3D принимает все трудные решения за вас автоматически, за кулисами.

Использование 2D флеш текста и спрайтов
Molehill игры могут использовать флеш-файлы. Вы можете использовать любой из старых Flash классов, точно также как делали это раньше. Вы можете добавить текст на сцену, воспроизводить звуки, потоковое видео, загружать XML-файлы, и использовать метод addChild() , чтобы добавить что либо на сцену, так же как и раньше. Эти объекты будут рисоваться поверх Stage3D объектов.

Рис 1.6 2D флеш

Это означает, что если вы хотите чтобы 2D графика Flash, такая как спрайты или текст рисовались поверх вашей 3D-графики, вы можете это сделать. Однако, вы не можете сделать это наоборот: вы не можете заставить отрисовываться объекты Stage3D поверх любых 2D объектов Flash. Объекты Stage3D рендерятся первыми, перед любой отрисовкой 2D – объектов.

Хорошей новостью является то, что Molehill может сосуществовать с старыми Flash 2D Displayobject, вы можете использовать весь ваш старый код, который определяет кнопки, видео, анимацию, или звуки. Вы просто накладываете какие-либо Displayobject‘ы, поверх вашего 3D-мира.

Это идеальный способ, для создания HUD (графический интерфейс пользователя) вашей игры. Вы можете использовать 2D Flash объекты, для того чтобы нарисовать шкалу здоровья, очки игрока, кнопки, водяные знаки, заставочные экраны, или что-нибудь еще, что вам необходимо иметь, но что не является составляющей 3D мира.

Почему Stage3D работает так быстро?
Adobe обошла многие узкие места, используемые в предыдущих версиях Flash, чтобы получить лучшую производительность. Самое большое отличие от старомодного способа ведения дел заключается в том, что ваши Stage3D объекты не являются Displayobject, (имя для всех вещей которые можно рисовать во Flash). Displayobject-базовый класс для стандартных Flash-объектов, которые добавляются в список отображения и могут иметь вращения, режимы наложения, фильтры, и многие другие эффекты, которые можно применить к ним.

Вы все еще можете использовать все эти старые классы в ваших играх. Просто нужно знать, что Stage3D объекты не являются Displayobject – они поддерживают GPU ускорение. Также была создана новая модель визуализации видео, называемая Stage Video, в которой Flash Player отправляет все данные для обработки непосредственно в видеопамять, которая потом выводит их на экран с помощью GPU.

Как только Flash отбросил все старые привычки, его производительность стала очень впечатляющей. Однако, у него есть ограничения, которые вы должны знать очень хорошо: Stage3D объекты не добавляются в список отображения Flash! Так как эти объекты не являются Displayobject, вы не можете применять к ним фильтры или режимы наложения. Вы не можете даже заставить рисоваться Stage3D объект поверх другой 2D графики Flash!

Флеш предоставил вам контроль над Stage3D, вашим GPU. Но он не играет «по правилам». Он поэтому и обеспечивает невероятную производительность, потому что он обходит использование DisplayList и отрисовывает объекты на экране непосредственно с GPU. Больше не используется обратное чтение для получения кадров из памяти, чтобы затем добавить их на экран через список отображения.

Molehill-особый случай, он предоставляет вам полный контроль над визуализацией объектов, используя ваш GPU. Flash по сути не вмешивается в работу объектов Stage3D. Они получают приоритет, и они не вытаскиваются с списка отображения, который удобен, но является раздутым и неэффективным.

Это конечно ограничивает применение Stage3D в дизайне, но это стоит скорости Stage3D. Хорошей новостью является то, что вы всегда можно обойти это ограничение, если вам жизненно необходимо чтобы 3D рисовалось поверх вашего 2D. Одним из способов сделать это, будет отрисовка всей вашей 2D графики (Flash Displayobject) за экраном и копирование этих пикселей в BitmapData, которая может быть загружена как новая текстура, и использована в вашем 3D-мире. Например, вы можете декодировать потоковое видео и скопировать его BitmapData в 3D-прямоугольник в вашем 3D-мире, так чтобы этот прямоугольник был позади другой 3D-графики.

Не отчаивайтесь, все возможно. Вы можете рисовать все, в любом порядке, вам просто иногда придется обходить эти правила. Помните: Molehill всегда отрисовывает 3D объекты первыми, перед любыми Displayobject.

Molehill супер быстрый, стабильный, и очень простой. Он делает только одну вещь, и делает ее хорошо!

Структура Molehill приложения
В Flash, сцена – это то, что рисуется на экране. Спрайты различных видов (растровые изображения, текстовое поле ввода, векторные фигуры) все добавляется к сцене. Molehill добавляет в Flash особого вида объект, который называется Stage3D. В Stage3D также как и в Stage отрисовываются объекты, но только те которые растеризует GPU. Вы можете иметь больше, чем одну Stage3D на вашей сцене. Каждая Stage3D имеет объект Context3D.

Context3D по сути является «3D движком». Это самый важный объект Molehill.

Рис 1.7 Context3D

Ваши игры будут, как правило, использовать тольку одну Stage3D вашей Stage, а она в свою очередь будет использовать только один Context3D. Context3D это объект, в который вы отправляете все ваши текстуры, вершинные буферы, и вершинные/фрагментные программы. Context3D является базовым классом, который содержит все ваши игровые данные и выполняет всю работу.

Как разработчик игр использующий Molehill, вы будете взаимодействовать с двумя главными объектами: Stage3D и Context3D. Запрашивая Context3D вашего Flash Player, вы говорите вашей видеокарте подготовиться к рисованию объектов на экране.

Stage
Это обычная флеш-сцена; все, что должно быть нарисовано на экране, необходимо добавить к ней.

Stage3D
Stage3D-это объект, который соединяет Flash и GPU. В отличие от обычных 2D объектов Flash, таких как TextArea или Sprite, Molehill Stage3D не добавляется в список отображения. Это означает, что вы не можете делать addChild() к объекту Stage3D. Она находится за всем вашим обычным flash-контентом. Она всегда находится на самом нижнем слое Stage. Вы можете иметь больше чем одну Stage3D на вашей сцене.

Context3D
Ваш Stage3D будет содержать объект Context3D. Это похоже на то, как растровая картинка содержит BitmapData и когда вы изменяете какие-либо параметры картинки, вы на самом деле влияете на ее BitmapData, так же и в Molehill, вы редко взаимодействуете с Stage3D, вместо этого вы работаете с Context3D. Вы можете думать о Context3D как о «3D-движке». Это объект, в который вы посылаете все ваши 3D-данные. Когда вы загружаете данные о вершинах, в вашу видеокарту, вы посылаете массив с числами в ваш Context3D.

VertexBuffer3D
Как мы узнали в предыдущей главе, модель в 3D-игре, называется меш – и состоит из сотен и тысяч вершин. Каждая вершина определяется координатами x,y,z, и является углом вашего меша. VertexBuffer3D – это массив чисел, которые могут быть использованы для определения этих координат.

Вы можете поместить любой тип данных в него, какой захотите. Вы не ограничены только x,y,z, вы можете записать в него какую-то информацию о цвете (rgb), данные о координатах текстуры UV, или даже пользовательские данные, которые понадобятся вам для ваших вершинных или фрагментных шейдеров.

После того как вы инициализировали вашу 3D игру, вы можете отправить этот гигантский массив с данными в Molehill, путем отправки VertexBuffer3D в ваш Context3D. Context3Dзатем загрузит эти данные непосредственно в вашу память видеокарты, и будет готов для использования их во время рендеринга.

Рис 1.8 VertexBuffer3D

IndexBuffer3D
Так как VertexBuffer3D это просто гигантский кусок числовых данных, Flash необходимо знать, где начинается каждый «кусок» и заканчивается. Индексный буфер просто объясняет Molehill, какая часть данных относится к каждой вершине. В предыдущем примере, в изображении, вы можете видеть, что индексный буфер определяет три записи о вершинах, каждая из которых имеет значения x,y,z и r,g,b. Так как существуют три записи в вашем IndexBuffer, то ваш меш будет выглядеть как треугольник: полигон с тремя углами.

Program3D
Вершинные программы и фрагментные программы, также называемые шейдерами – закачиваются в вашу видеокарту, так они смогут выполняться в GPU (графический процессор в вашем 3d оборудовании). Программы пишутся на специальном языке, который похож на ассемблер. Эти программы говорят вашему GPU, как рисовать меш, для которого вы только что загрузили все необходимые данные. В следующей главе, мы займемся созданием таких программ, но сейчас, просто думайте о них как о списке команд, которые хранятся в видеопамяти вместе с вашими вершинам и индексными буферами.

Схема последовательности выполнения операций программ Molehill
Когда вы используете Molehill, ваша программа будет состоять из двух частей: настройки и цикла рендеринга графики.

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

Во время настройки, все ваши буферы и программы, должны быть скомпилированы и отправлены в вашу видеокарту. Это делается только один раз. Один раз настроив, Flash может повторно отрисовать ваш меш в новых местах или даже несколько раз за одну отрисовку без необходимости создания новых, таких-же объектов. Установка может занять одну или две секунды, но после того как все данные будут готовы и будут находится в видеопамяти, вы можете использовать эти ресурсы снова и снова в вашей игре.

Вся эта подготовка-создание буферов и программ – способствует улучшению быстродействия отрисовки, потому что после того, как мы все это определили, все это находится непосредственно «в железе» (это работает внутри вашего GPU и больше не взаимодействует с CPU).

Время для действий – что мы должны сделать один раз, в процессе настройки игры
1. Запросить Context3D у Stage3D
2. Настроить Context3D (очень много возможностей)
3. Создать VertexBuffer (по одному для каждого меша, который вы собираетесь использовать)
4. Создать IndexBuffer (для каждого VertexBuffer)
5. Загрузить эти данные в Context3D (отправить в на ваш GPU)
6. Скомпилировать VertexProgram (превратить исходный код вашего шейдера в байты)
7. Скомпилировать FragmentProgram (превратить исходный код вашего шейдера в байты)
8. Создать Program3D, которая будет использовать ваши шейдеры (может использоваться несколько для одного меша)

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

Первый шаг состоит в получении ссылки на объект Stage3D и затем потребовать, чтобы Flash создал новый 3D контекст для вашей игры. После того как контекст будет создан, (есть событие, которое может сказать вам об этом), вы можете свободно загружать в него данные меша, программы и текстуры.

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

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

Время для действий – что мы должны делать снова и снова
1. Очистить Context3D (стереть старую графику)
2. Сказать Context3D, какие Program3D использовать снова (например, шейдер «ржавого металла»)
3. Сказать Context3D, какие VertexBuffer использовать снова (например, космический аппарат)
4. Настроить данные которые необходимы для ваших шейдеров (переменные, которые например определяют новое местоположение корабля)
5. Отрисовать какие-то треугольники (сказать Context3D нарисовать какой-то рисунок)
6. Обновить экран (показать пользователю новую сцену, вместо старой)

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

Викторина – заработайте очки опыта
Вот несколько простых вопросов, которые позволят проверить ваше усвоение материала. Если вы сможете ответить на них, то вы официально готовы перейти к следующему шагу своего грандиозного приключения.
1. Почему Molehill работает так быстро?
а. Он использует аппаратное ускорение 3D-графики
b. Все меши и шейдеры обрабатываются в GPU
c. CPU становится свободным для других вещей, потому-что и не участвует в рендеринге
d. Все перечисленное

2. Когда вы загружаете VertexBuffer, в какой объект вы будете его посылать?
а. Stage
b. Stage3D
c. Context3D
d. Ваш блог

3. Простейший меш, в виде треугольника, сколько имеет записей в индексном буфере (каждая из которых соответствует одной вершине)?
а. 1
b. 3
c. 2
d. 6

Резюме
Мы многое узнали в этой главе о приложениях использующих Flash 11 Stage3D (Molehill).
Мы рассмотрели:
‹ Старый способ отрисовки графики: 2D Flash использующий Displayobject
‹ Способ Molehill: Stage3Ds, содержащие Context3Ds
‹ Почему Molehill работает так быстро: Аппаратное 3D, детка!
‹ Сочетание 2D и 3D: Вы можете использовать старые и новые объекты Flash вместе
‹ Схему Molehill игр: Вначале настройка, затем цикл рендеринга
Теперь, когда мы узнали, как работает Molehill, мы готовы использовать эти знания, чтобы создавать игры.

Уровень 2 достигнут!
Поздравляем! ! ! Вы снова подняли свой уровень. В качестве бонуса уровня, вам разрешается начать создание вашей первой 3D-сцены в Flash. Это является темой следующей главы.

3. Запускаем Двигатели!
Вы почти достигли 3 уровня.
Теперь, когда вы изучили основные термины и структуру Stage3D API, пришло время, чтобы использовать эти знания на практике. Подготовтесь к вашей первой битве с боссом, на вашей 3D арене. Приготовьтесь к созданию вашего первого демо!

Выберите себе оружие и доспехи, отважный искатель приключений. Некоторые кодеры, используют в своей работе Flex, в то время как другие используют чистый AS3, а другие в то же время хотели бы работать в хорошо знакомой Adobe Flash IDE. Это ваш выбор.

В этой главе, мы будем:
‹ Устанавливать Flash 11 для вашего браузера
‹ Получать все инструменты, необходимые для компилирования Stage3D игр
‹ Инициализируем 3D-графику в Flash
‹ Отправим данные меша и текстуры в вашу видеокарту
‹ Анимируем, простую 3D сцену

Прежде чем мы начнем программировать, существуют два простых шага, которые необходимо выполнить, чтобы иметь возможность создавать удивительные 3D-игры. Шаг 1 состоит в том, чтобы получить плагин Flash 11 и Stage3D API. Шаг 2 – создание шаблона as3 проекта и проверка того, что он компилируется в рабочий Flash SWF файл.

После того, как вы выполните эти два шага, вы будете готовы к дальнейшим действиям. Вы будете по-настоящему в полной боевой готовности. Если вы добились того, что ваш инструмент настроен правильно, то вы будете готовы для того, чтобы начать писать 3D игры.

Шаг 1: Загрузка Flash 11 (Molehill)
В зависимости от вашего программного обеспечения, которое вы используете, установка Molehill будет слегка отличаться. Общее действие для всех, независимо от того, какой инструмент вы используете, вы должны будете скопировать файлы в определенную папку, но для некоторых программ вам возможно придется настроить несколько опций программы, чтобы все пошло как по маслу.

Если вы используете инструменты, которые вышли до 11 флеша, и продолжают пока еще жить, вам необходимо скачать некоторые дополнительные файлы с Adobe, которые научат эти инструменты обращаться с Stage3D. Как сделать это написано ниже в шаге 1.

В ближайшем будущем, конечно, Flash будет обновлен для использования Stage3D. Если вы используете CS5.5 или еще какой-либо новый инструмент, совместимый с плагином Flash 11, то вам может и не понадобиться выполнять указанные ниже действия. Если это так, тогда сразу переходите к шагу 2.

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

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

На момент написания книги, Flash 11 находится в бета-версии, и вы можете скачать его со следующего URL:
http://labs.adobe.com/downloads/flashplayer11.html

Вы можете скачать его и с страницы обновления текущей версии Flash Player:
http://www.adobe.com/support/flashplayer/downloads.html

C этой страницы вы сможете установить или Active-X (IE) версию или Плагин (Firefox, и так далее) версию Adobe Flash Player. На этой странице также есть ссылки для удаления FP, если вы захотите вернуться к старой версии Flash. Так что не беспокоитесь, если вас не устроит FP 11 вы всегда сможете вернуть все назад.

Наконец, если вы захотите использовать Chrome для отладки, вам необходимо будет установить плагин-версию и затем выключить встроенную версию Flash в нем, набрав about:plugins в адресной строке вашего Chrome бара и нажать на кнопку Disable на старом плагине Flash, для того чтобы новый плагин, который вы только что скачали, смог работать.

Мы должны убедится, что вы установили подходящую версию Flash, прежде чем мы продолжим далее.

Чтобы проверить, может ли ваш браузер работать с Stage3D, что необходимый Flash плагин установлен, просто щелкните правой кнопкой мыши на любом содержимом Flash и убедитесь, что в нижней строчке контекстного меню указана версия 11,0,1,60 или выше FP, как показано на следующем снимке экрана. Если вы не видете такой номер версии FP в меню, значит вы используете старый плагин Flash 10.

Рис 1.9 Версия Flash Player

Кроме того, в некоторых браузерах, 3D ускорение не включено по умолчанию. В большинстве случаев, лучше будет если вы проверите эту опцию. Просто убедитесь, что у вас включено аппаратное ускорение, щелкнув правой кнопкой мыши на флеш-файле и выбрав вкладку options, а затем включив аппаратное ускорение, если оно отключено, как показано на следующем скриншоте:

Рис 1.10 Аппаратное ускорение

Вы можете прочитать больше о том, как настроить Flash 11 по следующему URL:
http://labs.adobe.com/technologies/flashpl…/flashplayer11/

Время для действий – настраиваем профиль Flash 11 в CS5
Теперь, когда вы имеете доступ к Stage3D, то есть Flash плагин установлен, вам необходимо добавить поддержку Stage3D в ваш инструментарий. Если вы используете версии программ, которые вышли после публикации этой книги, то скорее всего они уже включают поддержку Flash 11, и вам не нужно ничего делать – переходите сразу к Шагу 2.

Если вы собираетесь использовать Flash IDE для компиляции исходного кода, и вы используете Flash CS5, вам необходимо загрузить специальный .XML файл, который научит Flash работе с Stage3D. Файл может быть загружен из следующего URL:
http://download.macromedia.com/pub/labs/fl…file_022711.zip

Если предыдущая ссылка не работает, не волнуйтесь. Файлы, которые вам нужны, включенны в исходные коды, которые прилагаются к книге. Как только вы получите этот файл, вам нужно скопировать некоторые файлы в папки вашего CS5.
‹ FlashPlayer11.xml в: Adobe Flash CS5\Common\Configuration\Players
‹ файл playerglobal.swc в: Adobe Flash CS5\Common\Configuration\ActionScript 3.0\FP11

Перезапустите Flash Professional после этого, а затем выберите «Flash Player 11″ в параметрах публикации. Теперь у вас будут публиковаться SWF13 файлы.

Так как вы не используете Flex для компиляции кода, вы можете пропустить все следующие разделы, связанные с Flex.

Время для действий – обновляем Flex
Если вы собираетесь использовать чистый AS3 (используя FlashDevelop или Flash Builder), или даже просто Flex без каких-либо IDE, то вы должны получить исходный код версии Flex, который может работать с Stage3D.

На момент написания, самая свежая версия Flex была 19786. Вы можете скачать его с следующего URL:
http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+Hero

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

Например, если вы используете Flash Builder, как часть Adobe Flex SDK, создайте новый ActionScript проект: File | New | ActionScript project. Откройте панель Properties (щелкните правой кнопкой мыши и выберите Properties). Выберите ActionScript Compiler из списка слева. Выберите опцию Configure Flex SDK’s в правом верхнем углу, и укажите путь к Flex build 19786 а затем щелкните по кнопке OK.

Если вы используете FlashDevelop, то вы должны также настроить его для использования новой версии Flex, зайдя в меню Tools | Program Settings | AS3 Context | Flex SDK Location и указав путь к папке с вашим новым Flex.

Время для действий – обновляем файл playerglobal.swc в Flex
Если вы используете FlashDevelop, Flash Builder, или другой инструмент, такой как FDT, то компиляция ActionScript кода осуществляется Flex. Для того, чтобы заставить Flex распознавать код связанный с Stage3D, вам нужно обновить небольшой файл, содержащий определения всех новых AS3 API, которые вас будут необходимы.

Если вы скачали последнию версию Flex, то возможно вам и не потребуется ничего обновлять, как описано это в следующем разделе. Во время написания книги файл playerglobal.swc, который содержит Stage3D API был доступен по следующему URL:
http://download.macromedia.com/pub/labs/flashplatformruntimes/flashplayer11/flashplayer11_b1_playerglobal_071311.swc

Переименуйте этот файл в playerglobal.swc и поместить его в соответствующую папку. Компилятор, сам включит его в ваш проект. Вы просто должны скопировать этот файл в папку с вашим Flex, в папку flex/frameworks/libs/player/11

В некоторые редакторах кода, нет опции для выбора компиляции проекта под Flash 11 (пока). К тому времени, когда вы читать эту книгу, скорее всего все развивающиеся IDE уже обновятся. Однако, на момент написания книги, единственный способ компилировать под Flash 11 в FlashDevelop, заключался в том чтобы скопировать SWC в папку flex/frameworks/libs/player/10.1 и выбрать компиляцию проекта под версию Flash Player 10.1.

После того, как вы распаковали Flex в нужное место и скопировали файл playerglobal.swc в соответсвуюшую папку, запустите ваш редактор. Выберите компиляцию проекта под Flash 11 в вашей IDE – или под другую версию, которая связанна с папкой, в которую вы скопировали файл playerglobal.swc. Убедитесь, что ваш IDE будет компилировать исходный код вместе с этой SWC.

Для этого, например, в Flash Builder просто выберите «Flash Player 11″ в Publish Settings. Если вы используете FlashDevelop, создайте новый проект и зайдите в Project→ Properties → Output Platform Target, и выберите желаемый FP из раскрывающегося списка.

Время для действий – компилируем код в Flex используя параметр SWF Version 13
Stage3D считается частью будущей «Версии 13″ Flash и, следовательно, вам необходимо настроить ваш компилятор для компиляции исходного кода под эту версию. Вам нужно будет указать версию SWF 13, передав дополнительный аргумент компилятору Flex: -swf-version=13.

1. Если вы используете Adobe Flash CS5, и вы уже скопировали XML-файл, то описанное выше делать не обязательно, все будет сделано за вас автоматически.
2. Если вы используете Flex из командной строки, то вам достаточно просто добавить предыдущий параметр в скрипт сборки исходного кода.
3. Если вы используете Flash Builder для компиляции в Flex, откройте панель Properties (щелкните правой кнопкой мыши и выберите Properties). Выберите ActionScript Compiler из списка слева. Добавьте в Additional compiler arguments строчку: -swf-version=13. Это обеспечит компиляцию SWF версии 13. Если вы компилируете в командной строке а не в Flash Builder, то вам также необходимо передать этот параметр как аргумент компилятора.
4. Если вы используете FlashDevelop, то кликните по Project | Properties | Compiler Options | Additional Compiler Options, и добавьте строчку -swf-version=13 в текстовую область.

Время для действий – обновляем шаблон HTML файла
У вас вероятно уже имеется базовый HTML шаблон, который используется для включения Flash файлов SWF в web-страницу. Вам нужно сделать одно крошечное изменение в нем, чтобы включить аппаратное ускорение.

Flash не будет использовать аппаратное 3D-ускорение, если вы не обновите ваш HTML-файл, дописав туда необходимые инструкции. Все, что вам нужно сделать, это помнить, что параметр wmode должен быть установлен как direct.

Например, если вы используете JavaScript, для добавления Flash в ваш HTML (SWFObject.js), то не забудьте добавить этот параметр в HTML файл. Если же вы вставляете SWF используя базовые HTML-теги object и embed, то ваш HTML будет выглядеть следующим образом:

<object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000"  width="640" height="480">
<param name="src" value="Molehill.swf" />
<param name="wmode" value="direct" />
<embed type="application/x-shockwave-flash" width="640" height="480" src="Molehill.swf" wmode="direct"><embed>
</object>

Единственным по-настоящему важным параметром является wmode=direct (и имя вашего swf-файла), весь остальной код HTML файла, который вы использовали раньше для вставки Flash в вашу страницу остается тем же.

В будущем, если вы запустите с 3D демку и заметите что частота кадров, ведет себя нестабильно, то это скорее всего значит что вы не используете аппаратное 3D-ускорение. Убедитесь, что в вашем HTML файле wmode параметру установлено правильное значение.

Stage3D теперь настроена!
Вау! Вы официально сходили в оружейный магазин и оборудовали себя всем, что требуется для исследования глубин 3D графики Flash 11. Это было жестоко для вас. Но теперь мы можем окунуться в кодинг, и эта часть главы оказывается самой легкой.

Шаг 2: Приступаем к написанию кода.
В первом шаге, вы скачали и установили все, что вам нужно для того чтобы скомпилировать код использующий Stage3D. Используете ли вы Adobe CS5, Flash Builder, FlashDevelop, или вы компилируете код в командной строке Flex, скомпилированный исходный AS3 код, будет работать одинаково.

Вот демка приложения, которое мы напишем в этой главе: http://www.mcfunkypants.com/molehill/chapter_3_demo/

Если вы нетерпеливый тип, то можете скачать весь исходный код используемый в книге, который вы также могли бы написать, если бы следовали инструкциям в каждой главе книги, со следующего URL: http://www.packtpub.com/adobe-flash11-stage3d-molehill-game-programming-beginners-guide/book

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

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

Ради соответствия следующему исходному коду, создайте класс с именем Stage3dGame, который расширяет класс Sprite, и сохраните его в as3 файл под именем Stage3dGame.as.

Как вы это сделаете, зависит от вашего выбора IDE.

Flash ветераны и художники, часто предпочитают работать в комфортной Adobe Flash IDE, в окружении своих старых друзей, таймлайна и библиотеки символов. Создайте новый файл .FLA, и настройте свой проект и сцену,так как считаете нужным. Не используйте какие-либо Flash MovieClip‘ы сейчас. Просто создайте пустой .FLA файл, с ссылкой на внешний .AS3 файл, как показано на следующем скриншоте:

Рис 1.11 Stage3dGame

Некоторые разработчики игр предпочитают работать с чистым AS3 кодом, без наворотов, которые связанны с использованием Flash IDE или Flex, который использует MXML-файлы. Этот метод позволяет создавать небольшого размера исходные файлы, и как правило, предусматривает использование open source (бесплатных) редакторов кода, таких как FlashDevelop. Если это ваше оружие, то все что вам нужно сделать, это создать пустой проект с основным as3 файлом, который установлен для компиляции по умолчанию.

Не важно, какой инструмент вы используете, после того как вы создадите пустой проект, ваш ультра-упрощенный исходный as3 код должен выглядеть примерно следующим образом:

package {
  [SWF(width="640", height="480", frameRate="60", backgroundColor="#FFFFFF")]
  public class Stage3dGame extends Sprite {
  }
}

Что же произойдет если сделать это?
Как вы можете догадаться, предыдущий исходный код не делает практически ничего. Это просто хорошее начало, мы создали пустой класс, готовый для заполнения всеми видами 3D игрового добра. Как только вы создали пустой Flash файл с предыдущим кодом и он компилируется без ошибок, то значит вы готовы начать добавлять Stage3D API к нему.

Время для действий – импорт классов для работы с Stage3D
Для использования вершинных и фрагментных программ (шейдеров), вам понадобится кое-какие классы от Adobe. Классы AGALMiniAssembler.as и PerspectiveMatrix3D.as поставляются вместе с исходниками для этой книги. Вы должны размесить их в папке com/adobe/utils/ своего проекта, чтобы они могли быть добавлены в ваш проект.

После того как вы добавили новые .as файлы в вашу папку с исходным кодом, добавьте следующие строки код в главный класс. Этот код импортирует различные функции и классы, и должен быть размещен непосредственно перед строчкой кода «public class Stage3dGame extends Sprite».

import com.adobe.utils.*;
  import flash.display.*;
  import flash.display3D.*;
  import flash.display3D.textures.*;
  import flash.events.*;
  import flash.geom.*;
  import flash.utils.*;

Что же произойдет если сделать это?
В строчках предыдушего кода, вы говорите Flash импортировать различные вспомогательные классы и функции, которые вы будете использовать в ближайшее время. Они включают 3D векторную математику, инициализацию Stage3D, и ассемблер, который используется для компиляции фрагментных и вершинных программ, то есть шейдеров.

Попробуйте скомпилировать код. Если вы получите всевозможные ошибки, упоминающие о неизвестных классах связанных с Molehill(например, Display3D), то это значит, скорее всего, что ваш компилятор настроен неправильно, или вы неправильно обновили файл playerglobal.swc, который мы скачивали ранее в этой главе. Вам необходимо еще раз проверить настройки компилятора и установку Flex, чтобы убедиться, что используется новый файл playerglobal.swc с включенным в него Stage3D API, а не его старая версия.

Если вы получаете ошибки, которые жалуются на отсутствующие com.adobe.utils файлы, то вы, возможно, не скопировали файлы AGALMiniAssembler.as и PerspectiveMatrix3D.as в правильное место. Проследите чтобы эти файлы находились в подпапке с именем com/adobe/utils/ в вашей папки с исходным кодом.

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

Время для действий – инициализация Molehill
Следующий шаг, получение Stage3D API и ее запуск. Добавьте следующие строчки кода в пустой класс вашего проекта. Просто измените код функции Stage3dGame функций и добавьте еще одну функцию init:

public function Stage3dGame() {
      if (stage != null) 
        init();
      else 
        addEventListener(Event.ADDED_TO_STAGE, init);
    }
 
private function init(e:Event = null):void {
      if (hasEventListener(Event.ADDED_TO_STAGE)) removeEventListener(Event.ADDED_TO_STAGE, init);
 
      // настраиваем сцену
      stage.scaleMode = StageScaleMode.NO_SCALE;
      stage.align = StageAlign.TOP_LEFT;
 
      // и запрашиваем context3D из Stage3D
      stage.stage3Ds[0].addEventListener(Event.CONTEXT3D_CREATE, onContext3DCreate);
      stage.stage3Ds[0].requestContext3D();
}

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

В функции init настраиваются некоторые параметры масштабирования Flash сцены, а затем запрашивается Context3D. Так как это может занять некоторое время, мы вешаем листенер на событие, которые отправляется когда ссылка на контекст Stage3D будет получена.

Время для действий – определение некоторых переменных
Далее, нашей демке будут необходимы некоторые переменные. Мы определим их в самом верху определения нашего класса, выше всех функций, как показано ниже:

// константы используемые  при иницмализации
private const swfWidth:int = 640;
private const swfHeight:int = 480;
private const textureSize:int = 512;
 
//окно с 3D графикой на сцене
private var context3D:Context3D;
// скомпилированный шейдер, используемый для визуализации нашего меша
private var shaderProgram:Program3D;
// загруженные вершины нашего меша
private var vertexBuffer:VertexBuffer3D;
// загруженные индексы каждой вершины меша
private var indexBuffer:IndexBuffer3D;
//данные определяющие 3d меш
private var meshVertexData:Vector.<Number>;
// индексы определяюшие какие данные будут использованы для каждой вершины меша
private var meshIndexData:Vector.<uint>;
 
//матрицы, которые влияют на положение меша и углы камеры
private var projectionMatrix:PerspectiveMatrix3D = new PerspectiveMatrix3D();
private var modelMatrix:Matrix3D = new Matrix3D();
private var viewMatrix:Matrix3D = new Matrix3D();
private var modelViewProjection:Matrix3D = new Matrix3D();
// простой счетчик кадров используемый для создания анимации
private var t:Number = 0;

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

Время для действий – добавление текстуры
Прежде чем мы начнем создавать функции, которые выполняют всю необходимую работу, давайте определим текстуру. Скопируйте любое изображение в формате jpeg размером 512×512 в вашу папку с проектом, в папку где находятся ваши исходные файлы.

Если вы используете Flex или такие редакторы AS3 кода как Flash Builder или FlashDevelop, то вам не нужно делать то, что написано дальше. Если вы используете Adobe Flash CS5, то вам нужно будет открыть библиотеку символов (F11) и перетащить в нее jpg-файл (изображение станет частью вашего .FLA файла), как показано на следующем скриншоте:

Рис 1.12 Импорт картинки в библиотеку

Как только эта текстура будет находится в библиотеке, щелкните по ней правой кнопкой мыши и откройте ее свойства. Нажмите на кнопку Advanced, чтобы открыть список опций, поставьте флажок на опции Export for ActionScript и дайте этому классу имя myTextureBitmapData. Мы будем использовать этот класс позже.

Если вы используете Flash CS5, добавьте следующий код сразу после кода с другими переменными, которые вы недавно определили:

private var myBitmapDataObject:myTextureBitmapData = new myTextureBitmapData(textureSize, textureSize);
private var myTextureData:Bitmap = new Bitmap(myBitmapDataObject);
// Molehill текстура, которая будет использовать изображение myTextureData
private var myTexture:Texture;

Если вы используете Flex или другие редакторы AS3 кода, то у вас нет библиотеки символов, поэтому вам необходимо добавить графику в ваш проект написав некоторое количество кода. Вместо приведенного выше кода, определите свои текстуры в коде следующим образом:

[Embed (source = "texture.jpg")] private var myTextureBitmap:Class;
private var myTextureData:Bitmap = new myTextureBitmap();
// Molehill текстура, которая будет использовать изображение myTextureData
private var myTexture:Texture;

Что же произойдет если сделать это?
Код, который вы только что написали, встраивает JPG-изображения в ваш проект, которые вы выбрали для использования в качестве текстуры. Эти текстуры будут, в конечном счете, натянуты на меш, который мы определим ниже.

Время для действий – определение геометрии вашего меша
В нашей демке, мы будем использовать простой меш, который будет являться квадратом («quad»). Мы определим его следующим образом:

private function initData():void {
 
  // Определяем какие вершины используется для каждого полигона
  // В этом примере, квадрат состоит из двух треугольников
  meshIndexData = Vector.<uint> ([0, 1, 2,     0, 2, 3,]);
 
  // Исходные данные для каждой из 4-х вершин
  // Позиция XYZ, текстурные координаты UV, нормаль XYZ
  meshVertexData = Vector.<Number>  ( [
    //X,  Y,  Z,   U, V,   nX, nY, nZ    
     -1, -1,  1,   0, 0,   0,  0,  1,
      1, -1,  1,   1, 0,   0,  0,  1,
      1,  1,  1,   1, 1,   0,  0,  1,
     -1,  1,  1,   0, 1,   0,  0,  1
  ]);
}

Что же произойдет если сделать это?
Предыдущая функция заполняет несколько переменных числовыми данными. Эти данные, в конечном счете, будут загружены в видеокарту и использованы для определения местоположения каждой вершины вашего меша. Наш меш, является простым квадратом, состоящим из двух треугольников, которые используют всего четыре вершины. В будущем ваши модели будут иметь сложные структуры, созданные из тысячи полигонов.

Что угодно, будь то меч, или целый город, может быть построен путем простого перечисления x,y,z координат в пространстве, соответствующих каждой вершине меша. Но сейчас, будем довольствоваться простым квадратом. Как только мы сможем заставить вращаться квадрат в 3D, добавить более сложные модели не составит для нас никакой особо сложности.

Время для действий – запускаем движок
Напомню, в функции init() запрашивается объект Context3D. Был добавлен слушатель этого события, чтобы Flash мог работать с Context3D безопасно, только тогда, когда ваша видеокарта будет подготовлена и готова к получению данных. Давайте напишем обработчик этого события.

Идеальное место для этого нового фрагмента кода, находится чуть ниже функции init() :

private function onContext3DCreate(event:Event):void {
  //если контекст запрашивается не впервый раз, останавливаем цикл рендеринга
  removeEventListener(Event.ENTER_FRAME,enterFrame);
 
  // Получаем текущий контекст
  var t:Stage3D = event.target as Stage3D;          
  context3D = t.context3D;   
 
  if (context3D == null) {
    // Если запросить текущий 3D контекст не удалось (ошибка!)
    return;
  }
 
  //Отключение проверки ошибок, позволит резко повысить производительность.
  //Если установлено значение true, Flash будет отсылать сообщения об ошибках. Полезно для отслеживания
  // AGAL ошибок, неинициализированных констант программ и т.д.
  context3D.enableErrorChecking = true;
  //Инициализируем данные меша
  initData();

Что же произойдет если сделать это?
Внутри обработчика onContext3DCreate, выполняется инициализация вашей Stage3D. Это подходящий момент для вашей игры, чтобы загрузить все изображения, которые будут использоваться во время игры.

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

‹ Может пройти некоторое время, прежде чем драйверы устройств, 3D видеокарта, операционная система, и Flash подготовят себя для работы с GPU.
‹ Иногда в середине вашей игры, Context3D может стать недоступным.
‹ Это может произойти, например, если компьютер пользователя переходит в состояние сна, или же была нажата комбинация клавиш Ctrl-Alt-Delete. По этой причине, вполне возможно, что во время процесса игры, данные меша и текстур нужно будет повторно загрузить в вашу видеопамять. Так как это может случиться не раз, эта функция будет предотвращать такую ситуацию, когда это необходимо.

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

Время для действий -добавляем еще кода в функцию onContext3DCreate
Следующее, что нам нужно сделать в нашей функции onContext3DCreate, так это определить размер области, в которую мы хотим рисовать объекты и создать простой шейдер, который проинструктирует Stage3D, как отрисовывать наш меш. Мы узнаем, что значат эти шейдерные команды подробнее в следующей главе. Добавьте в функцию следующий код:

// Размер заднего 3D буфера в пикселях
context3D.configureBackBuffer(swfWidth, swfHeight, 0, true);
// Простой вершинный шейдер, который осуществляет 3D трансформацию вершины
var vertexShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
vertexShaderAssembler.assemble ( Context3DProgramType.VERTEX,
  // умножаем 4x4 матрицу трансформации на полученный ракурс камеры  
  "m44 op, va0, vc0\n" +
  // рассказываем фрагментному шейдеру о XYZ
  "mov v0, va0\n" +
  //  рассказываем фрагментному шейдеру о UV
  "mov v1, va1\n"
);      
 
// Простой фрагментный шейдер, который отрисовывает вершину 
// и делает выборку цвета из текстуры для нее
var fragmentShaderAssembler:AGALMiniAssembler = new AGALMiniAssembler();
fragmentShaderAssembler.assemble ( Context3DProgramType.FRAGMENT,  
  //делаем выборку цвета текстуры из текстуры fs0
  // используя UV-координаты, хранящиеся в v1
  "tex ft0, v1, fs0 <2d,repeat,miplinear>\n" +  
  // отправляем это значение цвета на вывод
  "mov oc, ft0\n"                  
);
 
// комбинируем шейдеры в программу, которую затем загружаем в GPU
shaderProgram = context3D.createProgram();
shaderProgram.upload(vertexShaderAssembler.agalcode, fragmentShaderAssembler.agalcode);

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

Два объекта AGALMiniAssembler компилируют строчки кода, содержащие код AGAL (Adobe Graphics Assembly Language), в байт-код. Не волнуйтесь пока, что вы не понимаете AGAL код, мы займемся разбором фрагментных и вершинных программ в последующих главах. По сути, AGAL команды инструктируют вашу видеокарту, как ей отрисовывать меш.

Продолжим работать с функцией Context3DCreate.

Время для действий – загружаем наши данные
Для того, чтобы отрисовать меш, Stage3D нужно загрузить данные меша и текстуры в вашу видеокарту. Таким образом, после этого они будут доступны, для неоднократно использования, без необходимости каждый раз делать Flash эту «тяжелую работу».

// загружаем индексы меша
indexBuffer = context3D.createIndexBuffer(meshIndexData.length);
indexBuffer.uploadFromVector(meshIndexData, 0, meshIndexData.length);
// загружаем данные о вершинах меша такие как 
// x, y, z, u, v, nx, ny, nz
// каждая верщина использует 8 элементов массива
vertexBuffer = context3D.createVertexBuffer(meshVertexData.length/8, 8); 
vertexBuffer.uploadFromVector(meshVertexData, 0, meshVertexData.length/8);
 
// генерируем мип-уровни
myTexture = context3D.createTexture(textureSize, textureSize, Context3DTextureFormat.BGRA, false);
var ws:int = myTextureData.bitmapData.width;
var hs:int = myTextureData.bitmapData.height;
var level:int = 0;
var tmp:BitmapData;
var transform:Matrix = new Matrix();
tmp = new BitmapData(ws, hs, true, 0x00000000);
while ( ws >= 1 && hs >= 1 ) { 
    tmp.draw(myTextureData.bitmapData, transform, null, null, null, true); 
    myTexture.uploadFromBitmapData(tmp, level);
    transform.scale(0.5, 0.5); 
    level++; 
    ws >>= 1; 
    hs >>= 1;
    if (hs && ws) {
        tmp.dispose();
        tmp = new BitmapData(ws, hs, true, 0x00000000);
    }
}
tmp.dispose();

Что же произойдет если сделать это?
В предыдущем коде, наши данные меша загружаются в видеокарту. Сначала мы создаем вершинный и индексный буфер, загружаем в них данные о вершинах и индексах вершин, а затем загружаем текстуры. Также есть небольшой цикл, который создает такие-же текстуры, но меньших размеров и загружает их в память видеокарты. Эта техника называется MIP-уровни. При загрузке изображения размером 512×512, вслед за ней идут такие-же текстуры, только размером 256×256, затем 128×128, и так до 1х1. Видеокарта будет имеет набор текстур, которые могут быть использованы в зависимости от того как далеко или под каким углом смотрит на текстуру камера. MIP уровни гарантирует, что вы не получите «эффект лесенки» или «муаровый узор» и качество изображения будет на высоте.

Время для действий – настраиваем камеру
Есть один финальный кусок кода, который нам необходимо добавить в нашу функцию onContext3DCreate(). Нам просто нужно настроить угол наклона камеры и поручить Flash управление анимацией. Мы делаем это следующим образом:

// создать матрицу проекции нашей 3D сцены
projectionMatrix.identity();
// 45 градусов FOV, 640/480 соотношение сторон, 0.1=near, 100=far
projectionMatrix.perspectiveFieldOfViewRH(45.0, swfWidth / swfHeight, 0.01, 100.0);
// создаем матрицу, которая определяет местоположение камеры
viewMatrix.identity();
// перемещаем камеру немного назад, чтобы мы могли увидеть меш
viewMatrix.appendTranslation(0,0,-4);
// запускаем анимацию
addEventListener(Event.ENTER_FRAME,enterFrame);
}

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

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

Мы сделали все необходимые настройки Stage3D. Мы закончили написание функции onContext3DCreate.

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

private function enterFrame(e:Event):void  {
  // очищаем сцену перед каждой визуализацией
  context3D.clear(0,0,0); 
 
  context3D.setProgram ( shaderProgram );
  // осуществляем различные пробразования матрицы
  modelMatrix.identity();
  modelMatrix.appendRotation(t*0.7, Vector3D.Y_AXIS);
  modelMatrix.appendRotation(t*0.6, Vector3D.X_AXIS);
  modelMatrix.appendRotation(t*1.0, Vector3D.Y_AXIS);
  modelMatrix.appendTranslation(0.0, 0.0, 0.0);
  modelMatrix.appendRotation(90.0, Vector3D.X_AXIS);
  // поворачиваем в каждом кадре
  t += 2.0;
 
  // очищаем матрицу и добавляем новые углы
  modelViewProjection.identity();
  modelViewProjection.append(modelMatrix);
  modelViewProjection.append(viewMatrix);
  modelViewProjection.append(projectionMatrix);
 
  //отправляем данные матрицы в шейдерную программу
  context3D.setProgramConstantsFromMatrix(Context3DProgramType.VERTEX, 0, modelViewProjection, true );

Что же произойдет если сделать это?
В предыдущем коде, мы сразу же очищаем предыдущий экран с графикой. Затем назначаем шейдерную программу, которая будет визуализировать меш, эту программу мы определили в предыдущей функции, и устанавливаем матрице modelMatrix значения по умолчанию. modelMatrix представляет собой, трансформацию нашего меша. Изменяя положение (с помощью функции appendTranslation), а также вращение, мы можем передвигать наш меш куда будет нашей душе угодно.

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

// связываем данные вершины с текущей шейдерной программой
  // позиция
  context3D.setVertexBufferAt(0, vertexBuffer, 0,  Context3DVertexBufferFormat.FLOAT_3);
  // текстурные координаты
  context3D.setVertexBufferAt(1, vertexBuffer, 3, Context3DVertexBufferFormat.FLOAT_3);
  // нам нужно использовать текстуры?
  context3D.setTextureAt(0, myTexture);
 
  // наконец отрисовываем треугольники
  context3D.drawTriangles(indexBuffer, 0, meshIndexData.length/3);
 
  // показываем задний буфер
  context3D.present();
}

Что же произойдет если сделать это?
Как только мы передвинули все объекты куда нужно и подготовились для отрисовке следующего кадра (передавая Stage3D буфер вершин и текстуры, которые нам необходимо использовать), мы отрисовываем новую сцену вызывая метод drawTriangles и отображаем ее на экране.

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

Квест выполнен – время пожинать плоды
Теперь, когда весь исходный код написан, опубликуйте ваш SWF-файл. С помощью веб-браузера просмотрите опубликованный HTML-файл. Вы должны увидеть нечто, похожее на следующее:

Рис 1.13 Результат главы

Если вы ничего не увидите на экране при просмотре HTML-файла, который содержит ваш SWF-файл, то вероятно вы не правильно подключили Flash 11 плагин.

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

Поздравляем!!!
Вы написали свой первый Flash 11 Stage3D (Molehill) проект! Да, он не делает многого, но уже сейчас можно увидеть огромные возможности, впереди вас. Вместо простого крутящегося меша, вы можете, отрисовывать замки, монстров, гоночные автомобили или космические корабли, использовать систему частиц, и специальные эффекты, которые вы только можете себе представить. Все это и многое другое ждет тебя в следующих главах.

Гордитесь тем, что вы преодолели самое трудное – получили рабочую 3D демку. Многие до вас пытались это сделать и многим не удалось, либо потому, что они не работали с нужной версией Flash плагина, или не правильно настраивали свои редакторы кода, или, наконец, не смогли разобраться в сложном AS3 исходном коде.

То, что вы сделали это, свидетельствует о вашей квалификации и уровне програмирования. Вы заслуживаете перерыв. Отдыхайте с удовлетворением, так как вы только что достигли важной точки на пути к цели создания удивительных 3D-игр.

Исходный код
Весь код, который вы вводили ранее, должен находится в файле strongс именем Stage3dGame.as. Для того чтобы облегчить вам написание и проверку кода, сорцы для этой главы доступны по следующему URL:
http://www.mcfunkypants.com/molehill/chapter_3_source_code.zip
Сорцы сразу для всех глав книги можно скачать с следующего URL:
http://www.packtpub.com/adobe-flash11-stage3d-molehill-game-programming-beginners-guide/book

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

Рис 1.14 Структура папки проекта

Викторина – заработайте очки опыта
Вот несколько простых вопросов, которые позволят проверить ваше усвоение материала. Если вы сможете ответить на них, то вы официально готовы перейти к следующему шагу своего грандиозного приключения.
1. Какой класс используется для компиляции вершинных и пиксельных программ?
а. Context3D
b. AGALMiniAssembler
c. Vector3D
d. Я всегда летал первым классом

2. Почему мы должны ждать, получения события доступности контекста, прежде чем посылать данные в Stage3D?
а. Context3D не доступен сразу после того как его запрашивают
b. Событие может быть отправлено более одного раза, для того чтобы повторно загрузить данные в игровой процесс
c. Для предотвращения блокироки Flash во время инициализации
d. Все выше перечисленное

3. Что такое MIP уровни?
а. Специальная шейдерная команда AGAL
b. Визуализация меша более чем один раз
c. Создание все меньших версий одной и той же текстуры, для улучшения качества графики
d. Способ не заблудиться

Герой – ваш сторонний квест
Для того, чтобы оттачивать свои навыки, можно испытать самого себя, для получения некоторого дополнительного опыта. В конце каждой главы, есть побочный квест-без объяснения решения – он написан для вас, чтобы вы могли поэкспериментировать, но он не является обязательным к выполнению. Также как и в RPG играх, вы выполняете побочные квесты, для того чтобы стать сильнее, для того чтобы когда вам придется продвигаться вперед по основному квесту, вам было бы сделать это не так сложно.

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

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

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

meshVertexData = Vector.<Number>  ( [
    //X,  Y,  Z,   U, V,   nX, nY, nZ 
     -3, -1,  1,   0, 0,   0,  0,  1,
      1, -1,  1,   1, 0,   0,  0,  1,
      1,  1,  1,   1, 1,   0,  0,  1,
     -1,  1,  1,   0, 1,   0,  0,  1
  ]);

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

Если все это будет казаться слишком сложным для вас, не волнуйтесь. В конце концов, вы не будете определять меш вручную, перечисляя координаты его вершин в коде: в ближайшем будущем, мы модернизируем наш игровой движок для парсинга моделей, которые мы экспортируем из программ 3D-моделирования, таких как 3D Studio Max, Maya, или Blender.

Сейчас, однако, этот простой сторонний квест – отличный способ начать знакомство с вершинным буфером на деле.

Резюме
Вы вышли победителем из битвы с вашим первым боссом, на пути к созданию вашей собственной 3D видеоигры в Flash. Это было сложно, но нам каким-то образом удалось пройти через следующие ключевые этапы: мы узнали, как получить Flash 11 для нашего браузера, мы выбрали и настроили редакторы кода для компиляции игр под Stage3D, мы поняли как инициализировать Stage3D API, как загрузить данные меша и текстур в видео карту, и отрисовали простую 3D сцену.

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

Уровень 3 достигнут!
Вы успешно подняли свой уровень в третий раз. В качестве бонуса к третьему уровню мастера Molehill, ты заслужил право приступить к разработке cобственных сложных и красивых шейдеров, используя AGAL. Это является темой следующей главы.

Ответы на вопросы
Глава 1 Давайте делать игры на Molehill!
1 C
2 B
3 A

Глава 2 Проект Molehill.
1 D
2 C
3 B

Глава 3 Запускаем Двигатели!
1 B
2 D
3 C

Исходник: Stage3D_Code_Chapter03.zip
Перевод #redefy