Download [PDF 488 KB]

Популярная в Android-среде СУБД SQLite позволяет организовывать удобные хранилища данных, её возможностей достаточно для многих приложений, но не для тех, что работают с информацией, которую надо защищать. 

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

Лучшее, что может сделать почти любой разработчик, если речь заходит о шифровании – найти готовое, проверенное временем, широко используемое решение, и внедрить его в свой продукт. Одно из таких решений, подходящих для Android – SQLCipher. Это расширение для SQLite с открытым исходным кодом, которое поддерживает прозрачное 256-битное AES-шифрование файлов баз данных. 

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

SQLCipher была выпущена компанией Zeletic в 2008-м году и поначалу использовалась в собственных разработках компании, в частности, в менеджере паролей Strip. Позже надёжность, низкая нагрузка на систему и маленький размер SQLCipher сделали её одним из самых широко используемых решений для шифрования баз данных. В 2011 году, отвечая на многочисленные просьбы о поддержке SQLCipher на Android, Guardian Project и Zeletic выпустили соответствующую версию системы. SQLCipher доступна и на многих других платформах. В частности, это Windows C/C++, .NET, Ruby, Java, PHP, Python, QT, Mac OS X и Linux.

Мы поговорим о том, как скомпилировать SQLCipher для Android-устройств, построенных на платформе Intel x86, используя в качестве рабочей машины компьютер с установленной Linux.

В общих чертах, для интеграции в Android-приложение поддержки SQLCipher, нужно, во-первых, добавить в проект соответствующие библиотеки, во-вторых – вместо средств SQLite из android.database.sqlite.SQLiteDatabase, использовать аналогичные, но уже из net.sqlcipher.database.SQLiteDatabase. Подробнее об этом можно узнать здесь. 

Настройка Linux-окружения

Прежде чем скомпилировать SQLCipher для Android, нужно соответствующим образом подготовить компьютер с установленной Linux. В частности, надо загрузить и установить следующее:

1. Android SDK
2. Adnroid NDK
3. Java Development Kit (JDK)

На сайте Zeletic можно найти разные варианты загрузки исходного кода SQLCipher, мы сделаем это с помощью такой команды:

git clone https://github.com/sqlcipher/android-database-sqlcipher.git

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

Сборка библиотеки SQLCipher в Linux

Предположим, исходный код библиотеки находится в папке

/home/test/android-database-cipher/

Выполним следующие команды:

• Cd /home/test/android-database-cipher/
• ~/android-database-cipher> make init

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

• external/sqlcipher
• external/android-sqlite
• external/dalvik
• external/icu4c
• external/openssl
• external/platform-frameworks-base

Выполнение данной команды скомпилирует библиотеки для целевых архитектур, перечисленных в файле Application.mk. В нашем случае этот файл находится по адресу /home/test/android-database-cipher/jni/Application.mk. Для того чтобы получить версию библиотеки, собранную для платформы x86, он должен содержать такую строку

APP_ABI := x86

При успешной компиляции то, что нам нужно, окажется в папке libs/x86.
Сообщения об ошибках на данном этапе обычно указывают на неправильные настройки системы. Если при выполнении команды makeпоявится сообщение об ошибке вида «android update project fails», то, скорее всего, в системе пути к инструментам Android не добавлены в переменную PATH. Исправить это помогут такие команды:

export PATH=$PATH:~/android-sdk-linux/tools

export PATH=$PATH:~/ android-sdk-linux/platform-tools

Ошибку «ndk-build: command not found» вызывает отсутствие в переменной PATH сведений о расположении ndk-build. Её можно исправить так:

export PATH=$PATH:~/ android-ndk-linux /android-ndk-r10d

Если вы столкнулись с сообщением об ошибке «build.xml not found», автоматически сгенерировать build.xml можно так:

~/sqlcipher/android-database-sqlcipher> cd ..
~/sqlcipher> android update project --target 1 --path ./ --subprojects

Для того чтобы получить target id, можно воспользоваться командой android list targets.После того, как проблемы исправлены, снова запустите компиляцию, перейдя в каталог с исходным кодом SQLCipher.

Выводы

Мы рассмотрели здесь процесс подготовки SQLCipher для Android-устройств, построенных на платформе Intel x86 с использованием рабочей Linux-машины. Если вы работаете в Windows, здесь вы можете найти сведения о сборке SQLCipher на Windows-системах. Надеемся, SQLCipher поможет надёжно защитить данные всем, кто решит использовать эту библиотеку в своём проекте.

Download PDF

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

Поговорим об особенностях воспроизведения звука с высокой скоростью отклика на Android-устройствах, основанных на процессорах Intel Atom (Bay Trail). Применённый подход можно использовать и на других платформах от Intel. Здесь мы рассматриваем Android 4.4.4., подобное исследование для платформы Android M ещё находится в работе.

Предварительные сведения

Воспроизведение аудиоматериалов с высокой задержкой – одна из проблем Android, которая особенно сильно сказывается на приложениях для работы со звуком. Большие временные интервалы между действием пользователя и началом звучания плохо влияют на программы для создания звука, на игры, на софт для диджеев и караоке-приложения. Если подобные приложения, в ответ на некие действия, воспроизводят звуки с задержками, которые пользователь находит слишком большими, это серьёзно портит его впечатления.

В ходе исследования мы будем пользоваться понятием круговой задержки (Round-Trip Latency, RTL). В нашем случае это – это время, разделяющее момент выполнения пользователем или системой действия, требующего создания и проигрывания аудио-сигнала, и моментом начала звучания.

Пользователи сталкиваются с задержкой воспроизведения звука в Android, кода они, например, касаются объекта, взаимодействие с которым должно вызвать звук, а звук воспроизводится не сразу. На большинстве ARM и x86-устройств круговая задержка составляет от 300 до 600 мс., в основном – в приложениях, которые используют стандартные средства Android для вывода звука, описание которых можно найти в документе Design For Reduced Latency. 

Пользователи подобного не приемлют. Допустимая круговая задержка должна быть гораздо ниже 100 мс., а в большинстве случаев – и ниже 20 мс. В идеале, для профессионального использования, задержка должна быть ниже 10 мс. Ещё во внимание нужно принять то, что в Android-приложениях, работающих со звуком, общая задержка складывается из трёх составляющих. Первая – это задержка касания (Touch Latency). 

Вторая – задержка обработки звука (Audio Processing Latency). Третья – задержка постановки в очередь буфера с аудиоданными (Buffer Queuing).

Здесь мы сосредоточимся на сокращение задержки обработки звука, а не всех трёх вышеупомянутых составляющих. Однако, улучшив один из факторов, мы снизим и общую задержку.

Устройство звуковой подсистемы в Android

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

Здесь можно узнать подробности о вышеприведённой схеме. 

Отметим, что уровень аппаратных абстракций (Hardware Abstraction Layer, HAL) звуковой подсистемы Android служит связующим звеном между высокоуровневыми API, рассчитанными на обработку звука в android.media, и нижележащими аудиодрайверами и аппаратным обеспечением.

OpenSL ES

Использование API OpenSL ES – это наиболее надёжный способ эффективной обработки аудиосигнала, который должен воспроизводиться в ответ на действия пользователя или приложения. Задержек, и при использовании OpenSL ES, не избежать, но в документации к Android рекомендуется пользоваться именно этот API. 

Причина подобной рекомендации заключается в том, что OpenSL использует механизм постановки буферов с аудиоданными в очередь (Buffer Queueing), что повышает эффективность при работе в среде Android Media Framework. Всё это реализовано на машинном коде Android, то есть – может давать более высокую производительность, так как такой код не подвержен проблемам, характерным для Java или виртуальной машины Dalvik. 

Мы считаем, что использование механизмов OpenSL ES – это шаг вперёд в разработке аудио-приложений для Android. Кроме того, в документации к Android Native Development Kit есть сведения о том, что при выпуске новых релизов Android планируется улучшать и реализацию OpenSL.

Здесь мы рассмотрим использование API OpenSL ES посредством NDK. Для начала, вот три уровня кода, составляющие основу разработки звуковых приложений для Android с использованием OpenSL

• Верхний уровень – это среда разработки приложений Android SDK, которая основана на Java.
• Более низкий уровень программного окружения, называемый Android NDK, позволяет разработчикам писать код на C или C++, который можно использовать в приложениях с помощью механизма Java Native Interface (JNI).
• Нижний уровень – это API OpenSL ES, который поддерживается в Android, начиная с версии 2.3. API встроен в NDK.

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

Google рекомендует использовать при работе с OpenSL политику планирования Sched_FIFO. Эта политика основана на технике применения кольцевого буфера

Политика планирования Sched_FIFO

Так как Android основан на Linux, здесь задействуется планировщик Linux CFS. CFS может выделять ресурсы центрального процессора непредсказуемо. Например, он способен передать управление потоку с более высоким, на его взгляд, приоритетом, лишив полномочий потока, который кажется ему менее привлекательным. Таковы особенности CFS, если подобное коснётся потока, который занят обработкой звука, это способно вызвать проблемы с таймингами буферов. В результате – большие задержки, появление которых трудно предсказать.

Основное решение данной проблемы заключается в том, чтобы не использовать CFS для потоков, занятых интенсивной работой со звуком и, вместо политики планирования SCHED_NORMAL (другое её название – SCHED_OTHER), которую реализует CFS, применять политику SCHED_FIFO.

Задержка планирования

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

Руководствуясь вышеприведёнными соображениями, рассмотрим схему реализацию обработки звука на Android.

Интерфейс кольцевого буфера

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

1. Функция для создания кольцевого буфера.
2. Функция записи в буфер.
3. Функция чтения из буфера.
4. Функция для уничтожения буфера.

Вот пример кода:

circular_buffer* create_circular_buffer(int bytes);
int read_circular_buffer_bytes(circular_buffer *p, char *out, int bytes);
int write_circular_buffer_bytes(circular_buffer *p, const char *in, int bytes);
void free_circular_buffer (circular_buffer *p);

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

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

Ввод/вывод звука

Используя интерфейс, который мы рассматривали выше, функции ввода/вывода звука могут быть написаны с использованием функций обратного вызова OpenSL. Вот пример функции, обрабатывающей входной поток:

// обработчик функции обратного вызова, вызывается каждый раз, когда завершена запись в буфер
void bqRecorderCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
 OPENSL_STREAM *p = (OPENSL_STREAM *) context;
 int bytes = p->inBufSamples*sizeof(short);
 write_circular_buffer_bytes(p->inrb, (char *) p->recBuffer,bytes);
 (*p->recorderBufferQueue)->Enqueue(p->recorderBufferQueue,p->recBuffer,bytes);
}
// получает с устройства буфер с данными заданного размера
int android_AudioIn(OPENSL_STREAM *p,float *buffer,int size){
 short *inBuffer;
 int i, bytes = size*sizeof(short);
 if(p == NULL || p->inBufSamples == 0) return 0;
 bytes = read_circular_buffer_bytes(p->inrb, (char *)p->inputBuffer,bytes);
 size = bytes/sizeof(short);
 for(i=0; i < size; i++){
 buffer[i] = (float) p->inputBuffer[i]*CONVMYFLT;
 }
 if(p->outchannels == 0) p->time += (double) size/(p->sr*p->inchannels);
 return size;
}

В функции обратного вызова (строки 2-8), которая вызывается каждый раз, когда готов новый полный буфер (recBuffer), все данные записываются в кольцевой буфер. После этого функция снова ставится в очередь на выполнение (строка 7). Функция обработки звука (строки 10-21), пытается прочесть запрошенное число сэмплов (строка 14) в inputBuffer, а затем скопировать эти данные на выход (преобразуя их к формату с плавающей точкой). Функция возвращает количество скопированных сэмплов.

Вот пример функции, осуществляющей вывод звука:

// передаёт буфер заданного размера на устройство</pre>
int android_AudioOut(OPENSL_STREAM *p, float *buffer,int size){

short *outBuffer, *inBuffer;
int i, bytes = size*sizeof(short);
if(p == NULL || p->outBufSamples == 0) return 0;
for(i=0; i < size; i++){
p->outputBuffer[i] = (short) (buffer[i]*CONV16BIT);
}
bytes = write_circular_buffer_bytes(p->outrb, (char *) p->outputBuffer,bytes);
p->time += (double) size/(p->sr*p->outchannels);
return bytes/sizeof(short);
}

// обработчик функции обратного вызова, вызывается каждый раз, когда завершено воспроизведение данных из буфера
void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
 OPENSL_STREAM *p = (OPENSL_STREAM *) context;
 int bytes = p->outBufSamples*sizeof(short);
 read_circular_buffer_bytes(p->outrb, (char *) p->playBuffer,bytes);
 (*p->bqPlayerBufferQueue)->Enqueue(p->bqPlayerBufferQueue,p->playBuffer,bytes);
}

Функция обработки звука (строки 2-13) берет определённое количество данных, сохранённых в формате с плавающей точкой, конвертирует их в целые числа, записывает полный буфер outputBufer в кольцевой буфер, сообщает о количестве записанных сэмплов. Функция обратного вызова OpenSL (строки 16-22) считывает все сэмплы и ставит их в очередь.

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

while(on)

samps = android_AudioIn(p,inbuffer,VECSAMPS_MONO);

for(i = 0, j=0; i < samps; i++, j+=2)
 outbuffer[j] = outbuffer[j+1] = inbuffer[i];
 android_AudioOut(p,outbuffer,samps*2);
 }

В этом фрагменте кода в строках 5-6 производится обход считанных сэмплов и копирование их в выходные каналы. Здесь представлено преобразование входного монофонического сигнала в выходной стереофонический, именно поэтому одни и те же входные данные копируются в две идущих друг за другом позиции выходного буфера. Теперь, когда происходит постановка буфера в очередь, в потоках OpenSL, для того, чтобы запустить механизм обратного вызова, нам нужно поставить в очередь буфер для записи и ещё один – для воспроизведения после того, как мы начнём воспроизведение звука. Это позволит обеспечить срабатывание функции обратного вызова тогда, когда буферы нужно будет заменить.

Только что мы рассмотрели простой пример реализации потока ввода/вывода звука с использованием OpenSL. Каждая реализация будет уникальной и потребует модификаций HAL и драйвера ALSA для того, чтобы выжать из реализации OpenSL всё, что можно.

Доработка звуковой подсистемы Android на платформе x86

Различные реализации OpenSL не гарантируют, что на всех устройствах удастся достичь желаемого (до 40 мс.) уровня задержек при прохождении аудиосигнала к «быстрому микшеру» Android. Однако если выполнить модификации в Media Server, HAL, в драйвере ALSA, различные устройства могут, с переменным успехом, показывать хорошие результаты в деле обработки звука с низкими задержками. В ходе проведения исследования, посвящённого изучению того, что нужно для повышения скорости отклика при работе со звуком на Android, мы реализовали соответствующее решение на планшете Dell Venue 8 7460.

В результате экспериментов была создана гибридная система для обработки медиа-данных. В ней поток, обрабатывающий входные данные, управляется выделенным быстрым сервером, который обрабатывает исходный звуковой сигнал. Затем сигнал передаётся медиа-серверу, реализованному в Android, который использует поток «быстрого микшера». Серверы, обрабатывающие входные и выходные данные, используют механизм планирования OpenSL Sched_FIFO.

Реализация быстрой обработки звука, рисунок предоставлен Эриком Серре (Eric Serre)

В результате внесенных модификаций удаётся добиться вполне приемлемой RTL в 45 миллисекунд. Эта реализация опирается на Intel Atom SoC и на особенности устройства, использованного в эксперименте. Тест проведён на Intel Software Development Platform и доступен через Intel Partner Software Development Program.

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

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

Выводы

Мы обсудили особенности использования OpenSL для создания функции обратного вызова и очереди буферов в приложении, которое занимается обработкой звука на Android. Кроме того, здесь отражены усилия, приложенные Intel для достижения возможности работы со звуком с низкими задержками с использованием модифицированного Media Framework.

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

Download [PDF 623KB]

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

Сегодня мы расскажем о новом подходе к созданию системы защиты данных на Android, в основе которого лежит файловая системаeCryptfs.

Существующие решения

Начнём с того, что уже сделано в сфере защиты информации на Android. Существующие решения работают на различных уровнях системы.

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

Начнём с уровня ядра Linux, первого в нашей схеме. Сюда относится методика полного шифрования диска (Full Disc Encryption, FDE). ОС Android поддерживает FDE, начиная с версии 3.0. Полное шифрование диска – это кодирование всех пользовательских данных на устройстве с использованием зашифрованного ключа. После того, как данные зашифрованы, всё, что создаёт пользователь, перед записью на диск, так же шифруется. При чтении, перед передачей данных процессу, который их затребовал, они расшифровываются. Среднему разработчику можно об этом механизме и не знать. Если пользователи его применяют, в частности, используют экран блокировки с паролем, это защищает их данные от несанкционированного копирования.

Под вторым номером в нашей схеме находится уровень Android Framework. Для того чтобы реализовать систему шифрования данных, которая расположится на этом уровне, нужны root-права. Работать такая система будет на основе механизма перехвата управления. Приложение, которое планируется подобным способом защитить, может передавать, читать, записывать данные, пользуясь стандартными средствами, вызовы которых проходят через систему безопасности. 

Уровень приложения, третий номер в нашей схеме. Большинство существующих решений в области шифрования и безопасности можно отнести именно сюда. Это – немалое количество библиотек для разработчиков приложений. Среди них, например, OpenSSL, secureSqlite и другие.

Знакомство с eCryptfs

eCryptfs — это POSIX-совместимая криптографическая многоуровневая файловая система для Linux. Она хранит криптографические метаданные в заголовках файлов, таким образом, зашифрованные файлы можно копировать с одной системы на другую. Скопированный файл будет зашифрован с использованием подходящего ключа из набора ключей (keyring) ядра Linux. При этом нет необходимости хранить и обрабатывать какие-либо дополнительные данные, помимо тех, которые уже хранятся в файле.

Файловая система eCryptfs широко распространена и проверена временем. Например, на ней основано шифрование домашнего каталога в Ubuntu, она же применяется в ChromeOS и встроена в некоторые сетевые системы хранения данных. 

Архитектура решения, основанного на eCryptfs

При использовании eCryptfs шифрование и дешифрование данных выполняется автоматически. Вот схема архитектуры предлагаемого решения.

Архитектура решения на базе eCryptfs

Обратите внимание на то, что если в ядре Linux имеется модуль eCryptfs, взаимодействие с ним можно организовать с помощью службы (Service). Служба принимает команды от приложений, которые пользуются шифрованием, и отправляет запросы к VOLD (Volume Daemon), который, в свою очередь, выполняет действия с данными.
Вот какие запросы, касающиеся работы с безопасными директориями, выполняются к VOLD:

• Создать.
• Заблокировать. При этом VOLD размонтирует папку.
• Разблокировать. VOLD смонтирует папку, затем приложение может работать с данными в точке монтирования. Ядро будет автоматически шифровать и расшифровывать информацию.
• Удалить.
• Восстановить.
• Сменить пароли.

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

Место предлагаемого решения в структуре Android

Сделай сам

Если идея использования eCryptfs вам понравилась, хотим предложить схему её реализации.

Изменения, которые нужно внести в систему

Красные прямоугольники на рисунке – это новые блоки, которые нужно добавить в систему для организации безопасного хранения данных с использованием eCryptfs. Светло-серый цвет блока указывает на то, что соответствующий компонент требует настройки. А именно, общая схема работ по интеграции eCryptfs в Android такова:

1. Обеспечить поддержку eCryptfs ядром Linux.
2. Добавить в VOLD утилиты для поддержки eCryptfs и интерфейса eCryptfs.
3. Добавить основную службу, в том числе – библиотеку, которой смогут пользоваться приложения.
4. Добавить политики SELinux, которые позволят решению работать в новой системе.

Патчи для интеграции eCryptfs в ядро Linux на Android можно найти здесь.

Выводы

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

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

Джекоб Пеннок из компании Livid Interactive предлагает полезные советы по работе с технологиями Intel^® RealSense™и Unity* 5в этом наборе из семи видеороликов. Описание каждого видеоролика см. ниже.

Примечание. В некоторых видеороликах Джекоб ссылается на видео, описывающее модуль распознавания эмоций в составе SDK. Это видео уже недоступно, поскольку модуль распознавания эмоций упразднен и отсутствует в Intel^® RealSense™ SDK, начиная с версии R5.

Настройка набора инструментов Intel^® RealSense™ SDK в Unity* 5

Джекоб описывает, как импортировать набор инструментов Intel RealSense SDKв Unity 5 и проверить правильность установки, используя образец кода с перетаскиванием из Intel RealSense SDK. Примечание. Если установлена версия Intel RealSense SDK R4 или более поздняя, можно пропустить инструкции, касающиеся замены 32-разрядных двоичных файлов на 64-разрядные, поскольку начиная с версии R4 набор инструментов поставляется с 64-разрядным двоичными файлами для Unity 5.

Оптимизация для набора инструментов Intel^® RealSense™ SDK — часть 1

В этом наборе из двух видео, посвященных оптимизации, Джекоб рассказывает об областях набора инструментов Intel RealSense, где производительность недостаточна для рабочего приложения. В первой части описывается значительное повышение кадровой скорости за счет использования SenseToolkitMgr.Update(). Также показано, как устранить проблему зеркалирования в одном из образцов набора инструментов.

Оптимизация для набора инструментов Intel^® RealSense™ SDK — часть 2

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

Использование Intel^® RealSense™ SDK непосредственно в Unity* 5 (без набора инструментов)

В этом видео говорится о доступе к Intel RealSense SDK непосредственно из кода C# Unity 5. Набор инструментов Intel RealSense может быть полезен для быстрого тестирования, но разработчики могут добиваться более эффективной работы приложений, реализуя собственные способы взаимодействия с Intel RealSense SDK. Джекоб перечисляет основные действия, необходимые для этого.

Intel^® RealSense™ SDK + Unity* 5 — полезный совет: следите за кадровой скоростью

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

Альтернативные режимы отслеживания рук в Intel^® RealSense™ SDK и Unity* 5

В составе пакета Intel RealSense SDK есть несколько примеров отслеживания движения рук путем распознавания суставов. В этом виде Джекоб показывает еще одну методику отслеживания рук в режиме Extremities и итоговое сегментированное изображение. Этот метод работает гораздо быстрее, чем отслеживание с распознаванием суставов.

Intel^® RealSense™ SDK + Unity* 5 — полезный совет: отображение сегментированных изображений

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

Intel^® RealSense™ SDK + Unity* 5 — полезный совет: используйте отдельный поток для обновления

Джекоб описывает свой новый ноутбук Asus со встроенной камерой Intel^® RealSense™и показывает, как повысить производительность приложения, используя отдельный поток для взаимодействия с Intel RealSense SDK.

Об авторе

Джекоб Пеннок (Jacob Pennock) — специалист по технологии Intel^® RealSense™. Он занимает должности старшего творческого разработчика в компании Helios Interactive Technologies и главного игрового дизайнера/ведущего разработчика в компании Livid Interactive.

Назовите самый лучший формат сжатия текстур. Может это PNG, ETC, PVRTC, S3TC, или ещё какой-нибудь? Вопрос непростой, но очень важный. От ответа зависят качество визуального оформления, скорость работы и размеры Android-приложений. Дело осложняется тем, что универсального «самого лучшего формата» попросту не существует. Всё зависит от потребностей разработчика.

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

Предварительные сведения о работе с текстурами и о форматах их хранения

Наложение текстур (texture mapping) – это метод «наклеивания» изображения на поверхности фигур или многоугольников. Для того чтобы было понятнее, фигуру можно сравнить с коробкой, а текстуру – с узорной обёрточной бумагой, в которую эту коробку заворачивают для того, чтобы положить в неё что-нибудь хорошее и кому-нибудь подарить. Поэтому в англоязычной литературе наложение текстур называют ещё и «texture wrapping», что можно перевести как «обёртывание текстурами». 

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

MIP-карты (Mipmaps) – это оптимизированные группы изображений, которые генерируются для основной текстуры. Обычно их создают для того, чтобы увеличить скорость рендеринга картинки и для сглаживания изображений (anti-aliasing), то есть – для избавления от эффекта «ступенчатых» линий. Каждый уровень карты (его называют «mip», фактически – это одно из растровых изображений, из них состоит набор текстур, входящих в MIP-карту) – это версия исходной текстуры с пониженным разрешением. 

Такое изображение используется в случаях, когда текстурированный объект виден с большого расстояния, или когда его размеры уменьшены. Идея использования MIP-карт строится на том факте, что мы попросту не можем различить мелкие детали объекта, который находится далеко от нас или имеет маленькие размеры. Основываясь на этой идее, различные фрагменты карты можно использовать для представления различных частей текстуры, основываясь на размерах объекта. Это увеличивает скорость рендеринга за счёт того, что уменьшенные варианты основной текстуры имеют намного меньше текселей (пикселей текстуры), то есть GPU приходится обрабатывать меньше данных для вывода текстурированной модели. Кроме того, так как MIP-карты обычно подвергаются сглаживанию, серьёзно уменьшается количество заметных артефактов. Здесь мы рассмотрим MIP-карты в форматах PNG, ETC (KTX), ETC2 (KTX), PVRTC, и S3TC.

MIP-карта

Portable Network Graphics (PNG)

PNG – это растровый формат хранения изображения, особенно заметный тем, что в нём используется алгоритм сжатия графических данных без потерь информации. Он поддерживает цветные индексированные изображения (24 бита RGB или 32 бита RGBA), полноцветные и полутоновые изображения, а так же – альфа-канал.

Преимущества:

• Формат использует сжатие графических данных без потерь, как результат, PNG-изображения весьма качественны.
• Поддерживает и 8-ми битную и 16-битную прозрачность.

Недостатки:

• Файлы имеют большие размеры. Это увеличивает размер приложений и потребление памяти.
• Сравнительно высокая потребность в вычислительных ресурсах (что ведет к ухудшению производительности).

Ericsson Texture Compression (ETC)

Ericsson Texture Compression – это формат сжатия текстур, который оперирует блоками пикселей размером 4x4. Изначально Khronos использовал ETC как стандартный формат для Open GL ES 2.0. (эта версия ещё называется ETC1). В результате этот формат доступен практически на всех Android-устройствах. С выходом OpenGL ES 3.0. в качестве нового стандарта использован формат ETC2 – переработанная версия ETC1. Основное различие между этими двумя стандартами заключается в алгоритме, который оперирует пиксельными группами. Улучшения в алгоритме привели к более высокой точности вывода мелких деталей изображений. Как результат, качество изображений улучшилось, а размер файлов – нет.

ETC1 и ETC2 поддерживают сжатие 24-битных RGB-данных, но они не поддерживают сжатие изображений с альфа-каналом. Кроме того, есть два разных формата файлов, относящихся к алгоритму ETC: это KTX и PKM. 

KTX – это стандартный формат файла Khronos Group, он предоставляет контейнер, в котором можно хранить множество изображений. Когда MIP-карта создаётся с использованием KTX, генерируется единственный KTX-файл. Формат PKM-файла гораздо проще, такие файлы, в основном, используют для хранения отдельных изображений. Как результат, при использовании PKM в ходе создания MIP-карты получатся несколько PKM-файлов вместо единственного KTX. Поэтому для хранения MIP-карт использовать формат PKM не рекомендуется.

Преимущества:

• Размер ETC-файлов, заметно меньше чем размер PNG-файлов.
• Формат поддерживает аппаратное ускорение практически на всех Android-устройствах.

Недостатки:

• Качество не так высоко, как у PNG (ETC – это формат сжатия изображений с потерями информации).
• Нет поддержки прозрачности.

Для сжатия изображений в ETC можно использовать Mali GPU Texture Compression Tool и ETC-Pack Tool.

PowerVR Texture Compression (PVRTC)

PowerVR Texture Compression – это формат компрессии графических данных с потерями, с фиксированным уровнем сжатия, который используется, преимущественно, в устройствах Imagination Technology PowerVR MBX, SGX и Rogue. Он применяется в качестве стандартного метода сжатия изображений в iPhone, iPod, iPad. 

В отличие от ETC и S3TC, алгоритм PVRTC не работает с фиксированными блоками пикселей. В нём используется билинейное увеличение и смешивание с низкой точностью двух изображений низкого разрешения. В дополнение к уникальному процессу сжатия, PVRTC поддерживает формат RGBA (с прозрачностью) и для варианта 2-bpp (2 бита на пиксель), и для варианта 4-bpp (4 бита на пиксель).

Преимущества:

• Поддержка альфа-каналов.
• Поддержка RGBA для варианта 2-bpp (2 бита на пиксель) и для варианта 4-bpp (4 бита на пиксель).
• Размер файлов намного меньше, чем у PNG.
• Поддержка аппаратного ускорения на GPU PoverVR.

Недостатки:

• Качество не так высоко, как при использовании PNG (PVRTC – это формат сжатия изображений с потерями).
• PVRTC поддерживается только на аппаратном обеспечении PoverVR.
• Обеспечивается поддержка квадратных POT-текстур, то есть текстур, ширина и высота которых являются степенью числа 2, хотя в некоторых случаях имеется поддержка прямоугольных текстур.
• Сжатие текстур в этот формат может быть медленным.

Для сжатия можно использовать PVRTexTool.

S3 Texture Compression (S3TC) или DirectX Texture Compression (DXTC)

S3 Texture Compression – это формат сжатия графических данных с потерями, с фиксированным уровнем сжатия. Его особенности делают этот формат идеальным для сжатия текстур, используемых в 3D-приложениях, рассчитанных на использование графического ускорителя. Интеграция S3TC с Microsoft DirectX 6.0 и OpenGL 1.3 способствовала его широкому распространению. Существует как минимум 5 различных вариантов формата S3TC (от  DXT1 до DXT5). Приложение-пример поддерживает чаще всего используемые варианты (DXT1, DXT3 и DXT5).

DXT1 обеспечивает наиболее сильное сжатие. Каждый входной 16-пиксельный блок конвертируется в 64-битный блок, состоящий из двух 16-битных RGB 5:6:5 цветовых значений и 2-х битной таблицы подстановок размером 4x4. Поддержка прозрачности ограничена одним цветом (1-битная прозрачность).

DXT3 конвертирует каждый блок из 16 пикселей в 128 бит, 64 бита приходятся на данные альфа-канала, 64 – на цветовую информацию. DXT3 очень хорошо подходит для изображений или текстур с резкими переходами между прозрачными и непрозрачными областями. Однако если градаций прозрачности нет, а прозрачные участки в изображении имеются, стоит рассмотреть использование DXT1.

DXT5, как и DXT3, конвертирует каждый блок из 16 пикселей в 128 бит, 64 бита приходятся на данные альфа-канала, 64 – на цветовую информацию. Однако, в отличие от DXT3, DXT5 подходит для изображений или текстур с плавными переходами между прозрачными и непрозрачными областями.

Преимущества:

• Размер файла значительно меньше аналогичного PNG-файла.
• Достойное качество, низкий процент артефактов в виде полосок, связанных с наложением цветов.
• Хорошая скорость кодирования и декодирования.
• Аппаратное ускорение на множестве GPU. На настольных системах поддерживается практически всеми решениями, постепенно распространяется и на платформе Android.

Недостатки:

• Качество ниже, чем у PNG (S3TC – это формат сжатия изображений с потерями информации).
• Поддерживается не на всех Android-устройствах.

Для работы с этим форматом можно пользоваться DirectX Texture Tool из DirectX (включен в DX SDK)

Доступ к данным текстур

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

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

Обратите внимание

Заголовок PVRTC упакован с учётом наличия члена данных 64-битного пиксельного формата (mPixelFormat в примере). В коде, скомпилированном для ARM, проводится выравнивание заголовка с добавлением к нему 4 дополнительных байтов, в итоге он, из исходного 52-байтового, становится 56-байтовым. Это приводит к тому, что при выводе на ARM-устройствах изображение искажается. В коде, скомпилированном для процессоров от Intel, подобного не происходит. Упаковка заголовка решает проблему с выравниванием на ARM-устройствах, в итоге текстура отображается правильно как на ARM-устройствах, так и на Intel-устройствах. 

Вот как выглядит искажение изображения на ARM-устройстве, вызванное выравниванием заголовка

О приложении-примере

Пример Android Texture Compression, фрагменты которого будут приведены ниже, позволяет всем желающим быстро сравнивать качество текстур пяти форматов. А именно, это Portable Network Graphics (PNG), Ericsson Texture Compression (ETC), Ericsson Texture Compression 2 (ETC2), PowerVR Texture Compression (PVRTC), и S3 Texture Compression (S3TC), который иногда называют DirectX Texture Compression (DXTC). 

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

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

Рассматриваемый здесь пример основан на коде, который создал Уильям Гуо (William Guo). Кристиано Феррейра (Christiano Ferreira), специалист по графическим приложениям Intel, дополнил его примером использования сжатия текстур ETC2. Загрузить код можно здесь. 

Форматы сжатия текстур: размеры и качество

Загрузка PNG

С MIP-картами в формате PNG можно работать с помощью простой функции glGenerateMipmap из Khronos OpenGL, которая была создана специально для этой цели. Мы, для чтения и загрузки PNG-файлов, воспользовались кодом, подготовленным Шоном Барретом (Sean Barret), stb_image.c, который находится в открытом доступе. Так же этот код используется для нахождения и выборки участка текстуры, который нужно обработать.

    // Инициализация текстуры

    glTexImage2D( GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, pData );

    // Поддержка MIP-карты

    glGenerateMipmap( GL_TEXTURE_2D );

Загрузка ETC / ETC2

Как было упомянуто выше, ETC-текстуры могут храниться в файлах формата KTX и PKM. KTX – это стандартный формат сжатия, используемый как контейнер для нескольких изображений, он идеально подходит для создания MIP-карт. В свою очередь, PKM создан для хранения отдельных сжатых изображений, поэтому создание на его основе MIP-карт приводит к необходимости генерировать множество файлов, а это неэффективно. Поддержка MIP-карт для ETC в примере ограничена форматом KTX. 

Khronos предоставляет библиотеку с открытым кодом, написанную на C (libktx), в которой поддерживается загрузка MIP-карт из KTX-файлов. Мы этой библиотекой воспользовались и реализовали код в функции LoadTextureETC_KTX, ответственной за загрузку текстур. Функция, которая непосредственно загружает KTX-файлы, называется ktxLoadTextureM. Она позволяет загружать нужную текстуру из данных в памяти. Эта функция – часть библиотеки libktx, документацию по ней можно найти на сайте Khronos.

Вот фрагмент кода, который инициализирует текстуру и предоставляет поддержку MIP-карт для формата ETC (KTX).

    // Создание обработчика (handle) и загрузка текстуры

    GLuint handle = 0;

    GLenum target;

    GLboolean mipmapped;

    KTX_error_code result = ktxLoadTextureM( pData, fileSize, &handle, &target, NULL, &mipmapped, NULL, NULL, NULL );

    if( result != KTX_SUCCESS )

    {

        LOGI( "KTXLib couldn't load texture %s. Error: %d", TextureFileName, result );

        return 0;

    }

    // Привязка текстуры

    glBindTexture( target, handle );

Загрузка PVRTC

Поддержка MIP-карт для PVRTC-текстур – задачка чуть посложнее. После чтения заголовка определяется смещение, которое равняется сумме размеров заголовка и метаданных. Метаданные идут следом за заголовком, они не являются частью изображения. Для каждого сгенерированного уровня карты пиксели группируются в блоки (различия зависят от того, применяется ли кодировка 4 бита на пиксель или 2 бита – и тот и другой варианты подходят для PVRTC). Далее, происходит поиск границ, фиксируется ширина и высота блоков. Затем вызывается функция glCompressedTexImage(), она идентифицирует двумерное изображение в сжатом формате PVRTC. Далее, вычисляется размер пиксельных данных и то, что получилось, добавляется к ранее найденному смещению для того, чтобы сгруппировать набор пикселей для следующего фрагмента карты. Этот процесс повторяется до тех пор, пока не будут обработаны все текстуры, из которых состоит карта.

    // Инициализация текстуры

    unsigned int offset = sizeof(PVRHeaderV3) + pHeader->mMetaDataSize;

    unsigned int mipWidth = pHeader->mWidth;

    unsigned int mipHeight = pHeader->mHeight;

    unsigned int mip = 0;

    do

    {

        // Определение размера (ширина * высота * bbp/8), минимальный размер равен 32

        unsigned int pixelDataSize = ( mipWidth * mipHeight * bitsPerPixel ) >> 3;

        pixelDataSize = (pixelDataSize < 32) ? 32 : pixelDataSize;

        // Выгрузка текстурных данных для фрагмента карты

        glCompressedTexImage2D(GL_TEXTURE_2D, mip, format, mipWidth, mipHeight, 0, pixelDataSize, pData + offset);

        checkGlError("glCompressedTexImage2D");

        // Следующий фрагмент имеет в два раза меньший размер, минимум – 1

        mipWidth  = ( mipWidth >> 1 == 0 ) ? 1 : mipWidth >> 1;

        mipHeight = ( mipHeight >> 1 == 0 ) ? 1 : mipHeight >> 1;

        // Переходим к следующему фрагменту

        offset += pixelDataSize;

        mip++;

    } while(mip < pHeader->mMipmapCount);

Загрузка S3TC

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

    // Инициализация текстуры

    // Выгрузка текстурных карт

    unsigned int offset = 0;

    unsigned int width = pHeader->mWidth;

    unsigned int height = pHeader->mHeight;

    unsigned int mip = 0;

    do

    {

        // Определение размера

        // В расширении определено: size = ceil(<w>/4) * ceil(<h>/4) * blockSize

        unsigned int Size = ((width + 3) >> 2) * ((height + 3) >> 2) * blockSize;

        glCompressedTexImage2D( GL_TEXTURE_2D, mip, format, width, height, 0, Size, (pData + sizeof(DDSHeader)) + offset );

        checkGlError( "glCompressedTexImage2D" );

        offset += Size;

        if( ( width <<= 1 ) == 0) width = 1;

        if( ( height <<= 1 ) == 0) height = 1;

        mip++;

    } while( mip < pHeader->mMipMapCount );

Выводы

В зависимости от конкретной ситуации, выбор наиболее подходящего формата хранения сжатых текстур может улучшить внешний вид изображений, серьёзно уменьшить размер приложения и значительно повысить производительность. Тщательный подбор оптимального метода сжатия текстур способен дать разработчикам и их приложениям серьёзные конкурентные преимущества. В приложении-примере Android Texture Compression показано, как работать с текстурами наиболее популярных в Android-среде форматов.Загружайте код и добавляйте в свои проекты поддержку наиболее подходящих для них форматов сжатия текстур.

Download PDF

Download Code Sample

Конкуренция на рынке мобильных развлечений огромна. Любители игр, когда им попадаются «тормоза», не скупятся на гневные отзывы: «Как это так? Еле тянет на моём новом телефоне, где всё должно летать? В топку разрабов! Давайте быстрые игры!». Иногда геймеры, конечно, перегибают палку, но дыма без огня не бывает. И если вашей новой игре досталась порция «ласковых слов», это серьёзный повод задуматься об улучшении её производительности. А ещё лучше, когда FPS и прочие подобные вещи стоят на повестке дня ещё до того, как игра выйдет на рынок. 

В этом руководстве представлен пошаговый пример анализа производительности, поиска узких мест и оптимизации вывода графики в Android-игре, которая использует OpenGL ES 3.0. Пример игры, которым мы пользуемся в экспериментах, называется «City Racer». Это – симулятор городских автогонок. Анализ производительности приложения выполнен с использованием набора инструментов Intel Graphics Performance Analyzers (Intel GPA).

Игра City Racer

Городское окружение и автомобиль построены из примерно 230000 полигонов (690000 вершин). Здесь применяется наложение диффузных материалов, освещённых единственным источником направленного света без теней. В демонстрационных материалах к этой статье находится программный код, файлы проекта и графические ресурсы, которые необходимы для сборки и запуска приложения. Рассматриваемые здесь оптимизации можно включать и отключать, в коде представлен и исходный, и улучшенный варианты игры.

Предварительные сведения

В основе этого материала лежит руководство Intel Graphics Performance Workshop for 3rd Generation Intel Core Processor (Ivy Bridge), которое поставляется с GPA. Мы перенесли идеи и методики этого руководства на OpenGL ES 3.0.

В ходе рассмотрения материала мы пройдём по последовательным шагам оптимизации игры. На каждом шаге выполняется анализ приложения средствами GPA для поиска узких мест. Затем, для того, чтобы решить найденную проблему, мы улучшаем приложение, после чего производительность замеряется вновь – для оценки эффекта оптимизации. Мы придерживаемся здесь плана работы, который используется в руководстве, имеющемся в документе Developer’s Guide for Intel Processor Graphics.

Для сборки игрового примера City Racer используется Android API 20 и Android NDK 10. Анализ производительности производится с помощью набора инструментов Intel GPA.

Intel GPA совместим с большинством Android-устройств. Однако, с тех из них, которые построены на платформе x86, можно получить наиболее подробные сведения о профилируемых метриках.

Забегая вперёд, хотим отметить, что в ходе оптимизации графическая производительность City Racer выросла на 83%.

О City Racer

Демонстрационная игра City Racer логически разделена на две части. Первая отвечает за симуляцию процесса автогонок, вторая – за вывод графики. Симуляция гонки включает в себя моделирование ускорения, торможения, поворотов автомобиля. Здесь же присутствует система, построенная по принципам искусственного интеллекта, ответственная за следование по маршруту и уклонение от столкновений. Код, реализующий этот функционал, находится в файлах track.cpp и vehicle.cpp, он не подвергается оптимизации.

Компоненты вывода графики, вторая логическая часть игры, включают в себя код для отрисовки моделей автомобилей и игровой сцены с использованием OpenGL ES 3.0. и нашего движка собственной разработки CPUT. Исходная версия кода представляет собой типичную первую попытку создания рабочего приложения. Некоторые архитектурные решения, использованные при его написании, ограничивают производительность.

Сетки моделей и текстуры загружаются из файла Media/defaultScene.scene. Отдельные сетки промаркированы в соответствии с тем, являются ли они частью сцены, размещаемой заранее, объектом, который размещается в игровом мире в ходе прохождения игры, или автомобилем, параметры вывода которого вычисляются в ходе симуляции. В игровом пространстве можно пользоваться несколькими видами камер. Основная камера следует за автомобилем. Дополнительная камера позволяет пользователю свободно осматривать сцену. Анализ производительности и оптимизация кода нацелены на работу с камерой, которая следует за автомобилем.

Для целей данного руководства City Racer, при запуске, оказывается в режиме паузы. Это позволяет пройти по всем шагам профилирования, используя идентичные наборы данных. Снять игру с паузы можно, либо сбросив флажок Pause в её интерфейсе, либо записав в переменную g_Paused значение false. Эту переменную можно найти в начале файла CityRacer.cpp.

Потенциал оптимизации

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

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

Значения производительности, которые мы здесь приводим, получены на Android-устройстве, в котором установлен процессор Intel Atom (Bay Trail). Если вы повторите наши испытания, полученные результаты могут отличаться, однако относительные показатели изменения производительности должны быть теми же самыми. Описанные процедуры улучшения игры должны привести к сопоставимому росту производительности.

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

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

В нижеприведённом коде из CityRacer.cpp показаны переменные, ответственные за включение и выключение оптимизаций. Состояние кода соответствует состоянию вышеприведённого фрагмента интерфейса.

bool g_Paused = true;
bool g_EnableFrustumCulling = false;
bool g_EnableBarrierInstancing = false;
bool g_EnableFastClear = false;
bool g_DisableColorBufferClear = false;
bool g_EnableSorting = false;

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

Первый шаг заключается в компиляции игры City Racer и установке её на Android-устройство. Если в вашей системе присутствует правильно настроенная среда разработки Android, то всё необходимое можно сделать с помощью файла buildandroid.bat, который находится в папке CityRacer/Game/Code/Android. 

После того, как игра установлена на устройстве, запустите Intel GPA Monitor, щёлкните правой кнопкой мыши по значку в системной области уведомлений и выберите System Analyzer.

System Analyzer покажет список платформ, к которым можно подключиться. Выберите ваше Android-x86 устройство и нажмите кнопку Connect.

Выбор платформы для анализа производительности

Когда System Analyzer подключится к устройству, он покажет список приложений, которые можно профилировать. Выберите City Racer и дождитесь запуска игры.

Список приложений, отображённый System Analyzer

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

Захват GPU-кадра для анализа

Исследование кадра

Откройте Frame Analyzer for OpenGL и выберите только что захваченный кадр City Racer. Это позволит в деталях проанализировать производительность GPU.

Запуск Frame Analyzer для исследования производительности GPU

Шкала времени, соответствующая вызовам OpenGL

На временной шкале, которая расположена в верхней части экрана, показаны равномерно распределённые «эрги» — единицы, в которых измеряется работа по выводу изображения. Обычно они соответствуют вызовам команд рисования OpenGL. Для того чтобы переключиться к более традиционному отображению шкалы времени, выберите параметр GPU Duration по осям X и Y. Благодаря этой установке мы сможем быстро понять, какие из эргов занимают больше всего времени видеоядра. Это позволит выяснить, на чём именно следует сосредоточить усилия по оптимизации. Если ни один из эргов не выделен, на панели справа отображается общее время, необходимое GPU для вывода кадра. В нашем случае это 55 мс.

Время, необходимое GPU для вывода кадра

Взглянув на вызовы команд рисования, мы можем обнаружить, что выполняется вывод множества элементов, которые, на самом деле, на экране не видны. Изменив, при просмотре результатов анализа кадра, данные, выводимые по оси Y, на Post-Clip Primitives, мы можем увидеть разрывы, которые помогают понять, какие вызовы рисования тратятся впустую из-за того, что объекты, которые они выводят, полностью скрыты другими.

Анализ вывода объектов, которые полностью перекрыты другими объектами

Здания в City Racer собраны в группы, соответствующие их пространственному расположению. Группы, которые не видны, мы можем не выводить, не загружая GPU работой, связанной с ними. Если, в интерфейсе игры, установить флаг Frustum Culling, каждый вызов команды рисования, прежде чем он будет передан видеоядру, проходит «проверку на видимость» в коде, который выполняется на центральном процессоре.

Установим флаг Frustum Culling, захватим с помощью System Analyzer ещё один кадр для анализа и взглянем на него с помощью Frame Analyzer.

Анализ кадра, полученного после оптимизации

Анализируя кадр, мы можем заметить, что число вызовов рисования снизилось на 22% — с 740 до 576. Общее время, необходимое GPU для вывода кадра, снизилось на 18%.

Количество вызовов команд рисования после оптимизации отсечения по пирамиде видимости

Время вывода кадра после оптимизации

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

Мелкие операции рисования

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

Блоки, на которые приходятся мелкие операции рисования

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

Если, после включения флага Barrier Instancing, захватить кадр с помощью System Analyzer и проанализировать его в Frame Analyzer, можно заметить серьёзный рост производительности.

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

Проанализировав кадр, мы видим, что число вызовов рисования сократилось на 90%, а именно – с 576 до 60.

Вызовы команд рисования до оптимизации

Вызовы команд рисования после оптимизации

Теперь общее время работы видеоядра, необходимое для вывода кадра, сократилось на 71%, до 13 мс.

Время вывода кадра после оптимизации

Термином «перерисовка» («overdraw») называется многократное рисование одних и тех же пикселей результирующего изображения. Перерисовка пикселей может повлиять на пиксельную скорость заполнения и увеличить время вывода кадра. Изучив метрику Samples Written, мы можем видеть, что каждый пиксель изображения в каждом кадре перерисовывается, в среднем, 1,8 раза (Resolution / Samples Written).

Показатель Samples Written до оптимизации

Сортировка вызовов рисования от близких к далёким объектам – это довольно простой способ уменьшить эффект перерисовки. При таком подходе конвейер видеоядра не станет перерисовывать пиксели, выведенные на предыдущем шаге.

Установим флаг Sort Front to Back, захватим с помощью System Analyzer кадр и проанализируем его с помощью Frame Analyzer.

Анализ результатов применения сортировки вызовов команд рисования

В итоге метрика Samples Written уменьшилась на 6%, а время работы GPU – на 8%.

Показатель Samples Written после оптимизации

Время вывода кадра после оптимизации

Изучая временную шкалу, мы заметили, что самый первый эрг требует максимального, для одной операции, времени GPU. Выбрав его, видим, что это – не вызов команды рисования draw, а вызов команды очистки экрана glClear.

Первый эрг

Действие, выполняемое в первом эрге

Видеоядро от Intel имеет встроенную возможность выполнения так называемой «быстрой очистки». Она занимает небольшую часть времени, которое требуется для стандартной очистки. Быструю очистку можно выполнить, если использовать при вызове glClearColor чёрный или белый цвета, задаваемые, соответственно, как (0, 0, 0, 0) или (1, 1, 1, 1).

Установим флаг Fast Clear и выполним традиционную процедуру по захвату кадра с помощью System Analyzer и его анализа средствами Frame Analyzer.

Анализ кадра после использования быстрой очистки

Проанализировав кадр, видим, что время GPU, необходимое для выполнения операции очистки, снизилось на 87%. А именно, на обычную очистку надо примерно 1,2 мс., а на быструю – лишь 0.2

Время работы GPU, необходимое для выполнения обычной очистки

Время работы GPU, необходимое для выполнения быстрой очистки

В результате общее время вывода кадра сократилось на 24% — до 9,2 мс.

Общее время работы GPU

Мы взяли типичную мобильную игру, находящуюся на ранней стадии разработки. Игру проанализировали с помощью Intel GPA и внесли в код изменения, рассчитанные на увеличение производительности. Сведём результаты различных этапов оптимизации в таблицу.

Оценивая любые результаты тестов производительности, следует учитывать то, что тестовое ПО и рабочие нагрузки могут быть оптимизированы, например, только для процессоров Intel. Приложения для тестирования, например, SYSmark и MobileMark, вычисляют показатели производительности, основываясь на измерениях, проведённых на конкретных вычислительных системах. На результаты может повлиять всё, что угодно: компоненты этих систем, установленное программное обеспечение, да и сам набор испытаний, и их последовательность – тоже.

Любое изменение каждого из этих факторов может привести к изменению результатов теста. Поэтому, принимая на основе информации из тестовых отчётов какие-либо решения, например, о покупке оборудования, следует собрать как можно больше сведений из различных источников. Нужно учитывать, что, например, тесты процессора «А», работающего в паре с оперативной памятью «Б», могут отличаться от тестов того же процессора в системе, в которой установлена память «В». Для того чтобы узнать подробности о производительности систем, загляните сюда.

Если подвести итоги всех оптимизаций, применённых к City Racer, то окажется, что частота кадров выросла на 300% — с 11 кадров в секунду – до 44. Рассматривая этот результат, стоит помнить о том, что мы начинали работу с изначально весьма неоптимальным приложением. Поэтому, если использовать ту же цепочку улучшений, которую мы здесь привели, в реальном проекте, выигрыш в производительности может и не оказаться столь же существенным.

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

Мы оптимизировали в этом руководстве учебную игру City Racer для того, чтобы дать вам лучшее оружие для борьбы с «тормозами»: рекомендации из Developer’s Guide for Intel Processor Graphics и Intel GPA. Желаем пятизвёздочных отзывов вашим играм.

Загрузить документ

Unity– это один из самых популярных игровых движков для мобильных платформ (Android и iOS). Множество разработчиков используют его для создания и выпуска игр. До того, как Unity поддерживал Android-устройства, построенные на платформе Intel, игры приходилось исполнять в эмуляторе, который заменял низкоуровневый ARM-код на x86-код. В результате некоторые игры, которые изначально не были рассчитаны на платформу x86, в эмуляторе не запускались, либо имели проблемы с производительностью. Сегодня, с ростом присутствия процессоров от Intel в мобильной среде, многие разработчики заинтересованы в поддержке Android-устройств, основанных на архитектуре x86. Разработчики хотят знать, как оптимизировать игры для такого оборудования.

В этом материале мы покажем, какой производительности можно добиться, разрабатывая Android-приложения, рассчитанные на платформу x86, поделимся советами по оптимизации игр на примере Hero Sky: Epic Guild Wars.

Игра Hero Sky: Epic Guild Wars

У компании Innospark, разработчика Hero Sky: Epic Guild Wars, имеется большой опыт в создании мобильных игр с использованием различных коммерческих игровых движков. Кроме того, у Innospark имеется и движок собственной разработки. Hero Sky: Epic Guild Wars – это первая игра компании, разработанная с использованием Unity и выпущенная на всемирном рынке. После публикации в Google Play, с ростом числа загрузок, компания начала сталкиваться с жалобами пользователей. На некоторых Android-устройствах, основанных на платформе Intel, игра попросту не работала, на других её производительность оставляла желать лучшего. В итоге в компании было принято решение портировать игру на платформу x86 и оптимизировать её. Здесь мы расскажем о том, как оптимизировали Hero Sky: Epic Guild Wars с использованием результатов профилирования приложения с помощью Intel Graphics Performance Analyzers (Intel GPA). В частности, поговорим о влиянии на производительность порядка вывода объектов и альфа-смешивания.
 

Предварительные сведения

Hero Sky: Epic Guild Wars – это онлайновая военная 3D-стратегия. Innospark разрабатывала и оптимизировала игру, пользуясь системой, основанной на Intel Atom (Bay Trail). Вот особенности эталонного устройства, применявшегося в тестах. Здесь приведены характеристики системы и результаты теста 3DMark.Устройство имеет экран размером 8 дюймов.

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

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

Оценивая результаты тестов, стоит помнить о том, что они могут быть оптимизированы в расчёте, например, только на микропроцессоры от Intel. Такие тесты производительности, как SYSMark и MobileMark, запускаются на конкретных системах, на которых установлены конкретные аппаратные компоненты, программное обеспечение. В их ходе выполняются определенные наборы действий. Любое изменение способно повлиять на результаты теста. Касается это программной и аппаратной составляющей устройства, а так же самого тестового приложения и набора испытаний. Поэтому, принимая на основе тестов какие-либо решения, например – о покупке устройства, постарайтесь найти как можно больше источников информации, в том числе о том, какие результаты показывает интересующее вас оборудование, работающее совместно с другим оборудованием. Подробнее о производительности вы можете узнать здесь.

После того, как игра была портирована для архитектуры x86, нагрузка на процессор снизилась примерно на 7,1%, FPS выросла на 27,8%, а время исполнения уменьшилось примерно на 32,6%. Однако, нагрузка на видеоядро выросла на 26,7% из-за роста частоты кадров.

В Innospark использовали Intel GPA для поиска узких мест в производительности центрального процессора и видеочипа в процессе разработки. Данные анализа приложения применялись для решения проблем с графикой и улучшения производительности игры.

В начале оптимизации с помощью Intel GPA System Analyzer было получено значение в 51.09 FPS, принятое за базовое. Graphics Frame Analyzer, который измеряет FPS только на стороне GPU, выдал значение в 120.9 FPS. Причина, по которой эти значения отличаются, кроется в том, что System Analyzer отслеживает поведение процесса в реальном времени, что включает в себя и работу CPU, и работу GPU. Graphics Frame Analyzer отслеживает только работу видеоядра и ту деятельность процессора, которая связана с отправкой данных драйверу и GPU.

Детальный анализ приложения с использованием Graphics Frame Analyzer

Копия экрана первоначальной версии приложения
Сразу после переноса кода игры на платформу x86, она показала 59,01 FPS. Игру детально проанализировали с помощью Graphics Frame Analyzer для того, чтобы сократить нагрузку на видеоядро (GPU Busy) и процессор (CPU Load). В таблице показаны сведения, полученные с помощью Graphics Frame Analyzer.

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

Анализ и оптимизация, направленные на снижение нагрузки на систему

Устранение ненужного альфа-смешивания

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

Graphic Frame Analyzer умеет настраивать вызовы команд рисования. Это даёт разработчику возможность протестировать программу и выяснить изменения в производительности, вызванные внесёнными изменениями, без модификации кода. Данную функцию можно найти на вкладке Blend State, которая находится в группе State.

Вот как можно включать и выключать альфа-смешивание в Graphics Frame Analyzer без модификации исходного кода приложения

В таблице показана более подробная информация о рисовании травы после выключения альфа-смешивания. Длительность работы GPU, в результате, снизилась на 26,0%. Кроме того, обратите внимание на то, что показатель чтения из памяти снизился на 97,2%.

Эффективное применение Z-отсечения

Когда 3D-видеокарта выводит объекты, объёмные фигуры из трёхмерного пространства (x, y, z) преобразуются в двумерные (их положение определяется координатами x и y). При этом Z-буфер, или буфер глубины, используется для хранения информации о глубине (о координате z) каждого экранного пикселя. Если два объекта сцены должны быть выведены на одном и том же пикселе, GPU сравнивает информацию о глубине и перекрывает цвет текущего пикселя новым, если новый объект находится ближе к наблюдателю. Процесс Z-отсечения верно воспроизводит привычное восприятие глубины пространства, выводя более близкие объекты первыми. Они скрывают объекты, расположенные дальше. Z-отсечение позволяет улучшить производительность при выводе скрытых поверхностей.

В игре есть два вида вывода окружения: небо (эрг №1) и трава (эрг №5). Так как большая часть неба находится позади травы, значительная площадь неба никогда в процессе игры показана не будет. Однако небо выводится первым, что препятствует эффективному использованию Z-отсечения.

Вызовы для рисования неба (эрг №1) и травы (эрг №5)

Вот как выглядит длительность работы GPU после изменения порядка вывода объектов.

Сравнение нагрузки на систему до и после изменения порядка вывода объектов в Graphics Frame Analyzer.

В таблице показаны более подробные сведения о рисовании неба после изменения порядка вывода объектов. Время работы GPU, в частности, уменьшилось на 88%. Обратите внимание ни на то, что объём данных, записанных в память, сократился примерно на 98,9%.

Результаты

В таблице показаны более подробные результаты оптимизации игры для платформы x86 после избавления от ненужного альфа-смешивания и изменения порядка вывода объектов. Длительность работы GPU уменьшилась примерно на 25%, чтение из памяти и запись в память сократились, соответственно, на 42,6% и 30.0%. System Analyzer показал, что FPS увеличилось всего на 1,06. Дело тут в том, что в Android используется режим вертикальной синхронизации и максимальное FPS ограничено 60 кадрами в секунду. А вот частота кадров в секунду, подсчитанная с помощь Graphics Frame Analyzer, выросла на 29,7%.

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

Основные показатели до и после оптимизации

Выводы

Когда вы приступаете к оптимизации игры для Android x86, сначала следует портировать её на эту платформу, а затем – отыскать узкие места. Средства профилирования способны помочь в измерении производительности и в поиске проблемы с быстродействием, относящимся к GPU. Мощный аналитический инструмент Intel GPA может дать возможность поэкспериментировать с графической составляющей приложения без внесения изменений в исходный код.

Download Document

Занимаетесь разработкой кросс-платформенного приложения или игры для Android? Если так, то вам стоит присмотреться к специальным инструментам. Например, к SDK Marmalade C++ 8.0 и игровому движку ShiVa3D. Сегодня мы поговорим об их применении для платформы Android x86.

Marmalade C++ SDK

Идея, лежащая в основе Marmalade SDK, звучит следующим образом: «написанное один раз запускается где угодно». Мысль это не новая, но вполне актуальная. Один и тот же код можно компилировать и исполнять на всех поддерживаемых платформах – вместо того, чтобы использовать разные языки программирования и API. Такая универсальность достигается благодаря API, основанному на C/C++, который играет роль уровня абстракции для API каждой из целевых платформ.

Marmalade SDK – это набор инструментов для разработки кросс-платформенных приложений. Сам он может работать в различных средах, мы будем пользоваться Windows. Marmalade включает в себя набор библиотек, примеров кода и инструментов для разработки, тестирования и развёртывания приложений на различных платформах. В частности – на Android x86. Пакет хорошо документирован.

Предварительная подготовка

Ниже мы поговорим об использовании Marmalade SDK в среде Windows. Если вы работаете в Mac OS, обратитесь к этому разделу документации.
Итак, перед установкой Marmalade SDK надо подготовиться. А именно, для дальнейшей работы нам понадобится:

• Windows 7 или более новая версия ОС;
• Java JRE 5 или выше;
• Microsoft Visual Studio 2008 SP1/2010/2012/2013/2015 (С++), подойдут различные варианты, в том числе – и Express-версии пакета;
• Scons (C++), ZeroBrane Studio (Lua);
• Среда разработки Android. Можно загрузить её с сайта Google или получить в составе Intel INDE;
• Android NDK. Если вы установили Intel INDE, NDK уже будет присутствовать в системе.
• Apache Ant (необязательно).

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

• Переменная ANDROID_SDK_ROOT должна содержать полный путь к папке Android SDK. В нашем случае SDK установлена в составе Intel INDE, данная переменная выглядит так: C:\Intel\INDE\IDEintegration\SDK
• Переменная ANDROID_NDK_ROOT, соответственно, должна указывать на папку Android NDK. В нашем случае это C:\Intel\INDE\IDEintegration\NDK
• Переменная JAVA_HOME содержит путь к JAVA JDK. В нашем случае – это C:\Program Files\Java\jdk1.7.0_79
• Переменная ANT_HOME должна указывать на папку Apache ANT. Например, она может выглядеть так: C:\ant\apache-ant-1.9.6
• В переменной Path, помимо прочего, должны содержаться пути к следующим папкам: JDK, JDK bin, NDK, ANT bin, Android SDK tools, Android SDK platform-tools. Пути разделяются точкой с запятой.

Редактируя переменные среды, будьте внимательны, проследите, чтобы в конце путей не было специальных символов или разделителей вроде «\».

Теперь, когда предварительная подготовка проведена, пришло время загрузить Marmalade SDK. Нас интересует, в частности, Marmalade Core. Прежде чем вам дадут ссылку на загрузку пакета, потребуется регистрация на сайте. После установки, для того, чтобы приступить к экспериментам, нужно будет ввести лицензионный код, который придёт на электронную почту, указанную при регистрации.

Разработка для Android x86 с использованием Marmalade SDK

Рассмотрим проект HelloWorld из набора примеров, который поставляется вместе с Marmalade SDK. В нашем случае проект находится здесь: C:\Marmalade\8.0\examples\HelloWorld

Содержимое папки примера HelloWorld

В папке находятся MKB и CPP-файлы для двух демонстрационных проектов. В них показаны разные способы, которыми Marmalade может поприветствовать мир. Имена файлов, относящихся к одному проекту, совпадают. 
Файл с расширением MKB содержит информацию о проекте. А именно:

• Параметры компиляции
• Информацию об используемых библиотеках
• Сведения о файлах с исходным кодом
• Данные о графических, звуковых и других ресурсах
• Параметры развёртывания проекта

Подробности об MKB-файлах можно найти в документации. CPP-файл – это исходный код проекта, написанный на C++.

Существует три способа работы с Marmalade-проектами. Все они связаны с MKB-файлами. Первый применяется при автоматическом создании проекта для используемой IDE, второй задействует инструменты командной строки, третий основан на использовании Marmalade Hub.

Работа с Marmalade-проектом в Visual Studio

Сделаем двойной щелчок по файлу IwGxHelloWorld.mkb. Marmalade, открыв интерфейс командной строки, выполнит для нас большую работу, которая в итоге приведёт к появлению рядом с этим файлом пары новых папок и к открытию в Visual Studio проекта IwGxHelloWorld_vc14.

Проект, открытый в Visual Studio

Скомпилируем проект и запустим его на x86-симуляторе Marmalade. Для этого выполним команду меню Debug > IwGxHelloWorld_vc14 Properties…

​

Команда IwGxHelloWorld_vc14 Properties

В появившемся окне нажмём на кнопку Configuration Manager.

Кнопка Configuration Manager

Теперь, в поле Configuration, выберем вариант x86 Debug. Нажмём кнопку Close.

Настройка конфигурации проекта

Вернувшись в основное окно Visual Studio, выполним команду меню Debug > Start Debugging.

Команда начала отладки проекта

Если появится окно с предупреждением, нажмём в нём кнопку Yes.

Окно с предупреждением

Если появится окно с сообщением об отсутствии отладочной информации, так же нажмём Yes. Теперь остаётся лишь ждать, наблюдая в окне Output за процессом подготовки нашего проекта к запуску. Если всё прошло так, как нужно, будет открыто окно Marmalade x86 Simulator с запущенным Hello World.

Проект HelloWorld успешно запущен в эмуляторе.

Сборка проекта из командной строки

В Marmalade SDK входит пакетный файл mkb.bat, который можно вызывать из командной строки для обработки MKB-файлов. Это позволяет ускорить работу. Предположим, наш MKB-файл называется Hello.mkb. Перейдём в папку, в которой расположен этот файл, и с помощью нижеприведённой команды выполним перестроение проекта для всех поддерживаемых платформ:
>>mkb.bat Hello.mkb–execute –rebuild

Если нужно работать с какой-то конкретной платформой, в нашем случае, с Android x86, в MKB-файл, в раздел option, можно внести следующее дополнение:

option

{

android-x86
}

Для сборки Debug и Release-версий проекта можно воспользоваться, соответственно, следующими командами:

>> mkb.bat Hello.mkb --execute --debug
>> mkb.bat Hello.mkb --execute --release

Для того чтобы mkb.bat можно было запускать из командной строки, нужно добавить путь к папке bin s3e для установленной копии Marmalade в переменную среды Path. Например, путь может выглядеть так: C:\Marmalade\8.0\s3e\bin.

Работа с Marmalade Hub

После установки Marmalade SDK в вашей системе будет установлен и Marmalade Hub. Это – набор инструментов, автоматизирующий работу с проектами. Запустим его и на первой странице выберем команду Create new project:

Создание нового проекта в Marmalade Hub

Появится окно создания нового проекта:

Окно создания нового проекта

Здесь нас интересуют следующие поля:

• В поле Type выберем Core C++;
• В поле Name введём имя проекта;
• В поле Location укажем директорию проекта;
• В поле Template выберем шаблон Empty C++;

После выполнения этих настроек нажмём на кнопку Create. Проект будет создан, в окне Marmalade Hub откроется новая закладка:

Новый проект в окне Marmalade Hub

Нас интересует платформа Android x86, поэтому нажмём на кнопку Create deployment и в появившемся окне настроим параметры развёртывания:

Настройка параметров развёртывания проекта

А именно, выберем Android в поле Platform, в списке поддерживаемых архитектур укажем GCC X86 ANDROID. Нажмём на кнопку Next. В следующем окне нам предложат указать имя пакета и его версию. Не будем менять стандартные значения, нажмём на кнопку Create. 

Проект для нужной архитектуры будет создан. Теперь его можно запустить в эмуляторе, для этого служит кнопка Run in simulator, доступная, когда выбрана закладка Project, или на устройстве. При условии, естественно, что к компьютеру подключено Android-устройство подходящей архитектуры, готовое к USB-отладке приложений. 

Для развёртывания и запуска проекта на устройстве (в нашем случае это планшет ASUS Fonepad 8, который построен на основе CPU Intel Atom Z3530) нажмём на кнопку Install and run on device. Если проект удалось удачно установить и запустить, об этом можно будет узнать из сообщения в строке состояния, выведенного зелёным цветом.

Успешная установка и запуск проекта на Android-устройстве

На устройстве будет запущен наш Marmalade-проект.

Двоичные файлы .SO и .OBJ проекта можно найти по адресу C:\MarmaladeTest\HelloWorld\build_helloworld_vc14\Debug_HelloWorld_vc14_gcc_x86_android. Это, соответственно, HelloWorld.so и HelloWorld.obj.

Сгенерированный APK-файл проекта (HelloWorld.apk) находится здесь: C:\MarmaladeTest\HelloWorld\deployments\HelloWorld.0.gcc_x86_android. Marmalade SDK 8.0 поддерживает как создание индивидуальных APK-файлов для конкретных вариантов платформы Android, так и универсальные файлы, содержащие версии библиотек для различных платформ (fat binary). При размещении проекта в Google Play можно загружать различные варианты APK-файлов для разных платформ. 

Игровой движок ShiVa3D

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

ShiVa3D – это набор инструментов для разработки трёхмерных игр. Всё в нём направлено на эту цель. В частности, он оснащён графическим редактором, рассчитанным на создание игр и приложений для Web, игровых консолей и мобильных устройств. А именно, с помощью ShiVa3D можно создавать приложения для Windows, Mac OS, Linux, iPhone, iPad, BlackBerry Tablet OS/BlackBerry 10, Android, Palm OS, Wii, WebOS, это автономные приложения и приложения, выполняемые в веб-браузере.

Движок использует OpenGL, OpenGL ES, или DirectX, может выполнять программный вывод графики. ShiVa3D поддерживает подключаемые модули, ставшие индустриальными стандартами, в частности, NVIDIA PhysX, библиотеку для работы со звуком FMOD и ARToolKit.

ShiVa3D Web Edition – это полная бесплатная версия, которую можно использовать для экспериментов.

В дополнение к вышеупомянутому редактору, ShiVa3D предоставляет разработчику ShiVa3D Authoring Tool – средство для авторинга проектов, созданных в редакторе для платформ Windows, Mac OS, Linux, iPhone, iPod, iPad, Android, BlackBerry QNX, и Palm.

Установка ShiVa3D

Прежде чем установить ShiVa3D, нужно будет подготовиться. В целом, нижеприведенный список дополнительных средств соответствует тому, что мы рассматривали выше, для подготовки к установке Marmalade SDK, однако, здесь есть и некоторые особенные требования, характерные для ShiVa3D. А именно, нам понадобятся:

• Windows 7 или выше;
• Среда разработки Android;
• Android NDK;
• Cygwin. Это приложение позволяет организовать в Windows рабочую среду в стиле Linux. При инсталляции Cygwin нужно выбрать и установить следующие пакеты: autoconf, automake, binutils, gcc-core, gcc-g++, gcc4-core, gcc4-g++, gdb, pcre, pcre-devel, gawk, make, python. Не забудьте выбрать GNU-версию make, иначе вы не сможете выполнять построение проектов с использованием NDK.
• Java JDK;
• Apache Ant;
• Microsoft Visual Studio C++;

Теперь стоит проверить переменные среды, и, если они при установке вышеописанных инструментов, не были правильно настроены, исправить это.

• Переменная ANDROID_SDK_ROOT должна содержать полный путь к папке Android SDK. В нашем случае SDK установлена в составе Intel INDE, данная переменная выглядит так: C:\Intel\INDE\IDEintegration\SDK
• Переменная ANDROID_NDK_ROOT, соответственно, должна указывать на папку Android NDK. В нашем случае это C:\Intel\INDE\IDEintegration\NDK
• Переменная ANT_HOME должна указывать на папку Apache ANT. Например, она может выглядеть так: C:\ant\apache-ant-1.9.6
• В переменной Path, помимо прочего, должны содержаться пути к следующим папкам: JDK, JDK bin, NDK, Cygwin bin, ANT bin, Android SDK tools, Android SDK platform-tools. Пути разделяются точкой с запятой.

Напоминаем, что редактируя переменные среды, стоит проследить за тем, чтобы в конце путей не было специальных символов или разделителей вроде «\».

Теперь всё готово к загрузке и установке ShiVa3D. В частности, нас интересует ShiVa3D Web Edition.
Пакет поставляется с множеством примеров, для первых экспериментов вы можете загрузить один из них. Для того чтобы это сделать, нужно, после запуска ShiVa Editor, воспользоваться кнопкой Open or Drop a Game в разделе Game Editor главного окна. Будет открыто окно Open со списком игровых проектов. Предполагая, что вы нашли игровой проект для экспериментов, рассмотрим процедуру экспорта проекта с помощью редактора ShiVa3D.

Экспорт проекта в STK-файл

Выполним команду General > Game Editor > Game > Export для запуска процедуры экспорта.

Запуск процедуры экспорта проекта в ShiVa3D

Заполним поля в появившемся окне, введя имя (name) и версию (version) экспортируемого приложения. Укажем расположение для файлов, которые будут получены в результате экспорта. В нашем случае используется папка D:\ShiVa3D_prog\game_export. Вы можете использовать любую другую папку.

Настройка параметров экспорта

Обратите внимание на то, что на выходе должен получиться единственный STK-файл, за это отвечает флаг Runtime Package.

Компиляция приложения с использованием ShiVa 3D Authoring Tool

После экспорта проекта закроем ShiVa Editor и запустим ShiVa 3D Authoring Tool.

Окно ShiVa 3D Authoring Tool

Выберем, в левой части окна, пункт Android, выполнив по нему двойной щелчок.

Окно ShiVa 3D Authoring Tool после выбора пункта Android

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

Выбор файлов для создания проекта

Нажмём на кнопку Settings, которая находится в правой нижней части окна, откроется экран настроек.

Окно настроек

В этом окне, в соответствующих полях, нужно указать пути к различным программным средствам, которые нужны для подготовки приложения. Среди них – Cygwin, Android NDK и другие.

После того, как ввод данных завершён, нажмём ОК, и, вернувшись в основное окно ShiVa 3D Authoring Tool, активируем вкладку Step 2: Authoring.

Переход к вкладке Step 2: Authoring

Здесь нужно ввести имя пакета приложения.

Работа с вкладкой Step 2: Authoring

Перейдём на вкладку Step 3: Build. Здесь можно задать параметры сборки. А именно – минимальную версию Android, целевую платформу (x86 в нашем случае), выходную директорию.

Настройка параметров сборки приложения на вкладке Step 3: Build

Установив подходящие значения, нажмём на кнопку Build, которая расположена в правой нижней части экрана. Если всё пройдёт успешно, система сообщит об этом.

Успешная компиляция приложения

Работая с ShiVa3D, мы ограничены использованием ShiVa 3D Authoring Tool, инструмента с графическим интерфейсом. Поддержка средств командной строки здесь не предусмотрена. Рассмотрим подробнее настройки Authoring Tool для подготовки приложений, рассчитанных на платформу x86.

Настройка ShiVa 3D Authoring Tool для платформы x86

1. Создайте приложение в ShiVa Editor и экспортируйте его. Обратите особое внимание на имя файла проекта. Оно должно состоять из прописных и заглавных букв латинского алфавита (a-z или A-Z), цифр (0-9), может включать в себя знак подчёркивания ( _). Другие символы в имени файла приведут к ошибкам на этапе компиляции. Важно учитывать, что игровой проект сначала нужно экспортировать средствами ShiVa Editor, а потом уже обрабатывать с помощью ShiVa Authoring Tool.
2. Откройте ShiVa 3D Authoring Tool, сделайте двойной щелчок по пункту Android. С этого момента вы можете воспользоваться вышеприведенным руководством с некоторыми отличиями. А именно, когда вы окажетесь на закладке Step 2: Authoring, вы увидите там поле Authoring type.

Поле Authoring type

По умолчанию в этом поле установлено значение APK Package. Если APK-пакет приложения, который можно тут же установить на устройство – это всё, что вам нужно, не меняйте значение данного поля. 

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

Если вам нужны исходные файлы, а не APK-пакет, выберите в поле Authoring type вариант Project. В итоге будет сгенерирован ZIP-файл с исходными файлами проекта, но APK-файл создан не будет.

Папка, в которую попадают сгенерированные при компиляции файлы (APK или ZIP), задаётся на закладке Step 3: Build, в поле Output folder. Для того чтобы до этого поля добраться, нужно воспользоваться полосой прокрутки.

Поле Output folder

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

Для выбора целевой платформы компиляции проекта служит поле CPU support на закладке Step 3: Build. Оно расположено выше поля Output folder. По умолчанию здесь установлено значение Default. Нас интересует пункт x86.

Выбор целевой платформы

Настраивая минимальную версию Android, необходимую для работы приложения и установив в поле Minimum OS support версию API меньше 9, вы можете столкнуться с ошибками.

Выбор минимальной версии Android API

О файлах, получаемых в результате компиляции проекта

После того, как вы учли всё то, о чём мы только что говорили, ваша ShiVa3D-игра готова к компиляции для платформы x86. То, что получится на выходе, зависит от выбранного варианта Authoring type: APK Package или Project. Однако, в любом случае, файлы окажутся в указанной выходной директории. Наша папка расположена по такому адресу: D:\ShiVa3D_prog\authoring_tool_output.

При выборе варианта APK Package в ней будет содержаться один .apk-файл:

D:\ShiVa3D_prog\authoring_tool_output\FistApp_1-debug.apk

При выборе варианта Project файл будет тоже один, но на этот раз – с расширением .zip:

D:\ShiVa3D_prog\authoring_tool_output\FistApp_1_Android.zip

Этот архив, в свою очередь, содержит двоичные файлы, файлы манифестов, make-файлы, ресурсы и build-файлы проекта.

Выводы

Из этого руководства вы узнали о том, как сделать первые шаги в работе с Marmalade SDK и ShiVa 3D, ориентируясь на платформу Android x86. Если вы задумываетесь о том, чтобы написать собственную мобильную игру, то, вполне возможно, один из этих инструментов окажется именно тем, что вам нужно. 

Оригинал статьи тут.

Введение

Робот, движущийся вдоль линий, входит в серию упражнений с образцами кода Intel для Интернета вещей. Здесь используется Intel® IoT Developer Kit, платформа разработки Intel® Edison, облачные платформы, API и другие технологии.

Выполнив это упражнение, разработчики научатся:

• подключать платформу разработки Intel® Edison, предназначенную для создания прототипов и носимых компьютерных устройств и решений Интернета вещей;
• подключаться к интерфейсу ввода-вывода платформы Intel® Edison и хранилищу датчиков с помощью MRAA и UPM из пакета Intel® IoT Developer Kit, представляющего собой полный набор аппаратных и программных компонентов, помогающих разработчикам изучать возможности Интернета вещей и создавать современные проекты;
• запускать этот образец кода в интегрированной среде разработки Intel® XDK IoT Edition, предназначенной для создания приложений, взаимодействующих с датчиками и приводами, и помогающей быстро приступить к разработке программного обеспечения для платы Intel® Edison и Intel® Galileo;
• сохранять данные об обнаружении линий с помощью Azure Redis Cache* в Microsoft* Azure*, настраивать облачные решения Интернета вещей, включая решения для анализа данных, машинного обучения и различных рабочих инструментов, чтобы упростить процесс подключения датчиков к облаку и помочь быстрее запустить проект Интернета вещей.

Что это такое

В этом проекте, используя плату Intel® Edison, можно создать робота, отслеживающего линии и обладающего следующими возможностями:

• Непрерывная проверка данных с датчика поиска линий.
• При обнаружении линии этим датчиком: поступательное движение с помощью шаговых двигателей.
• Если датчик не обнаруживает линию: поворот с целью найти ее (также с помощью шаговых двигателей).
• Запись событий с датчика поиска линий с помощью облачного хранилища данных.

Как это работает

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

Кроме того, система может записывать системные события с помощью хранилища IoT Examples и учетной записи Microsoft* Azure*.

Требования к оборудованию

Комплект Grove* Robotics Kit.

1. Плата Intel® Edison с коммутационной платой Arduino*
2. Датчик поиска линий Grove*
3. Шаговые двигатели и контроллеры шаговых двигателей (2 шт.)

Требования к программному обеспечению

1. Intel® XDK IoT Edition
2. Учетная запись Microsoft* Azure*

Инструкции по настройке

Чтобы приступить к работе, скопируйте хранилище How-To Intel IoT Code Samplesс помощью Git* на компьютер следующим образом:

$ git clone https://github.com/intel-iot-devkit/how-to-code-samples.git

Нужно загрузить ZIP-файл? В веб-браузере перейдите по адресу https://github.com/intel-iot-devkit/how-to-code-samplesи нажмите кнопку Download ZIPв правой нижней части экрана. После загрузки ZIP-файла распакуйте его и используйте файлы в папке этого примера.

Добавление программы в Intel® XDK IoT Edition

В Intel® XDK IoT Edition выберите Import Your Node.js Project.

Затем перейдите в папку примера проекта и выберите его.

Нужно подключить плату Intel® Edison к компьютеру, чтобы отправлять на нее код.

Щелкните меню IoT Deviceв левой нижней части экрана. Если плата Intel® Edison автоматически распознана, выберите ее.

В противном случае выберите Add Manual Connection. В поле Addressвведите 192.168.2.15. В поле Portвведите 58888. Щелкните Connect, чтобы сохранить подключение.

Установка программы вручную на плату Intel® Edison

Можно установить код на плату Intel® Edison вручную.

Скопируйте хранилище How-To Intel IoT Code Samplesна плату Intel® Edison после установки SSH-подключения к этой плате:

$ git clone https://github.com/intel-iot-devkit/how-to-code-samples.git

Затем перейдите в папку с примером.

Чтобы установить Git* на плату Intel® Edison, если это еще не сделано, установите SSH-подключение к плате и выполните следующую команду:

$ opkg install git

Подключение датчиков Grove*

Нужно подключить плату Grove* Shield к коммутационной плате, совместимой с Arduino*, и подключить все устройства Grove* к плате Grove* Shield. Убедитесь, что маленький переключатель VCC на плате Grove* Shield установлен в положение 5V.

Плату Intel® Edison необходимо подключить к адаптеру питания, входящему в комплект, или использовать любой другой внешний источник питания, выдающий 12 В и 1,5 А. Также можно использовать внешний аккумулятор, например USB-аккумулятор напряжением 5 В.

Кроме того, потребуется макетная плата и дополнительный источник питания 5 В для обоих двигателей. Примечание. Для питания двигателей требуется отдельный аккумулятор или источник питания. Невозможно использовать один и тот же источник питания и для платы Intel® Edison, и для двигателей: нужно либо два аккумулятора, либо два источника питания.

1. Подключите контроллеры всех шаговых двигателей к 4 контактам на коммутационной плате Arduino, чтобы можно было управлять работой двигателей. Подключите контроллер шагового двигателя # 1 к контактам 4, 5, 6 и 7. Подключите контроллер шагового двигателя # 2 к контактам 9, 10, 11 и 12. Подключите оба контроллера к земляному контакту (GND), к контакту электропитания 5 В от коммутационной платы Arduino* (VCC) и к отдельному источнику питания 5 В для двигателей (VM).
2. Подключите один конец кабеля Grove* к датчику поиска линий Grove*, а другой — к порту D2 на плате Grove* Shield.

Ручная настройка платы Intel® Edison

При запуске этого кода на плате Intel® Edison вручную необходимо установить зависимые компоненты.

Для получения модулей Node.js*, необходимых для запуска этого примера программы на плате Intel® Edison, выполните следующую команду:

npm install

Настройка сервера Microsoft* Azure*

При желании можно хранить данные, созданные этим образцом программы, во внутренней базе данных, развернутой с помощью Microsoft* Azure*, Node.js* и хранилища данных Redis*.

Сведения о настройке собственного облачного сервера данных см. по адресу

https://github.com/intel-iot-devkit/intel-iot-examples-datastore

Настройка примера программы

Чтобы настроить этот пример для использования хранилища данных Microsoft* Azure*, измените параметры SERVERи AUTH_TOKENв файле config.jsonследующим образом:

{ "SERVER": "http://intel-examples.azurewebsites.net/logger/line-follower", "AUTH_TOKEN": "s3cr3t" }

Запуск программы с помощью Intel® XDK IoT Edition

Перед запуском сохраните все файлы.

Щелкните значок Upload, чтобы отправить файлы на плату Intel® Edison.

Щелкните значок Runв нижней части окна Intel® XDK IoT Edition. В этом случае код будет запущен на плате Intel® Edison.

Если вы внесли изменения в код, щелкните Upload and Run. В этом случае на плате Intel® Edison будет запущена последняя версия кода со всеми изменениями.

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

Запуск программы вручную

Чтобы запустить пример программы на плате Intel® Edison вручную, установите SSH-подключение к этой плате и выполните следующую команду:

node index.js

Определение IP-адреса платы Intel® Edison

Определить IP-адрес подключенной платы Intel® Edison можно с помощью следующей команды:

ip addr show | grep wlan

На экране появится приблизительно следующий текст:

3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast qlen 1000 inet 192.168.1.13/24 brd 192.168.1.255 scope global wlan0

IP-адрес показан после слова inet. В приведенном выше примере используется IP-адрес 192.168.1.13.

Полный список образцов кода Intel для Интернета вещей см. на сайте Intel® Developer Zone.

Дополнительные сведения об этом образце кода см. в GitHub*.

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

Download PDF

Jack (Java Android Compiler Kit) – это компилятор, преобразующий исходный код на Java в DEX-файлы Android. Jack – это набор инструментов, среди его возможностей – переупаковка, сжатие, обфускация и поддержка множественных DEX-файлов.

В Jack используются промежуточные библиотеки в формате .jack. Преобразованием существующих .aar/.jar файлов в этот формат занимается Jill (Jack Intermediate Library Linker).

Если для сборки используется Jack, то сначала Jill конвертирует внешние библиотеки, используемые в проекте, в .jack-файлы. Это подготавливает библиотеки к быстрому слиянию с другими .jack-файлами на следующем этапе, когда Jack и плагин Android Gradle, используя подготовленные ранее.jack-файлы и исходный Java-код, компилируют DEX-файл (или файлы). В ходе этого процесса Jack может выполнить минификацию кода (сжатие, обфускацию, или и то и другое вместе). На выходе получается APK-файл Android-приложения.

Процесс сборки приложения с использованием Jack и Jill

Jack и Jill доступны в Build Tools для Android Studio начиная с версии 21.1.1. Плагин Android Gradle поддерживает эти инструменты, начиная с версии 1.0.0. Для того чтобы задействовать возможности Jack, достаточно добавить в файл build.gradle команду useJack=true.

Android SDK Manager

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

Узнать подробности о работе с Jack и Jill можно с помощью команд, приведённых ниже. Здесь мы пользуемся стандартным интерфейсом командной строки Windows, библиотеками Jack и Jill, включёнными в состав Android Build Tools версии 23.0.2.
Некоторые возможности этих инструментов могут быть доступны из командной строки раньше, чем их поддержка будет включена в плагин Android Gradle.

Итак, вот команда для получения справки по Jack:

• java –jar <SDK>/build-tools/< Build Tools version>/jack.jar –help

Справка по Jack

А вот так можно поближе познакомиться с Jill:

• java –jar <SDK>/build-tools/< Build Tools version>/jill.jar –help

Справка по Jill

Некоторые особенности Jack

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

При использовании Jack, ему можно передавать конфигурационные файлы Proguard с помощью параметра командной строки ––config-proguard. Если говорить о переупаковке, то Jack совместим с правилами типа «rule», но не с правилами типа «zap» или «keep». Файлы правил можно указывать в командной строке с использованием параметра –– config-jarjar.

Поддержка Jack плагином Android Gradle всё ещё в процессе разработки, поэтому стоит учесть следующие особенности и ограничения:

• Директива обфускации –applymapping ещё не поддерживается.
• Возможность переупаковки (вроде инструмента jarjar) пока не интегрирована.
• Средство Jacoco не поддерживается.
• Манипуляции с байт-кодом не поддерживаются.
• В некоторых случаях, при сборке очень больших приложений, можно столкнуться с исключением Out Of Memory. Справиться с проблемой можно, если настроить систему сборки на использование, как минимум, 2 Гб оперативной памяти:

dexOptions { javaMaxHeapSize"2048M" }

Попробуем Jack в деле.

Работа с Jack

Для начала нам понадобится какой-нибудь проект приложения для экспериментов. Например, импортируем из каталога примеров проект Hello JNI. Для этого выполним в Android Studio команду File > New > Import Sample. В появившемся окне найдём проект Hello JNI, и, выделив его название, нажмём на кнопку Next.

Проект Hello JNI для импорта

android {        

compileSdkVersion = 23

  buildToolsVersion = "23.0.2"

defaultConfig.with {.with {            

  applicationId = "com.example.hellojni"           

minSdkVersion.apiLevel = 4           

targetSdkVersion.apiLevel = 23           

  useJack = true       

}    

}

Теперь испытаем работу системы на планшете Asus Fonepad 8 (CPU Intel Atom Z3530, Android 5.0).

Тестовое приложение на x86-устройстве

Итоги

Каждый, кто занимался разработкой приложений, знает, что в этом деле на счету каждая секунда. Одна из важных особенностей Jack – это сокращение времени компиляции, а значит – повышение производительности труда. Кроме того, Jack по умолчанию используется в Android M. Пожалуй, только этих двух фактов достаточно для того, чтобы сделать Jack и Jill желанными гостями в доме любого программиста.

В этой статье вы узнаете об игре с дополненной реальностью, созданной с помощью камеры Intel® RealSense™ (заднего обзора), пакета Intel® RealSense™ SDK, игрового движка Unity 3d™и динамически изменяемого ландшафта (песка). Создатели компьютерных игр постоянно изучают новые способы расширения возможностей пользователя, помогающие игроку более полно погрузиться в игровой мир. При этом разработчики постоянно предоставляют пользователям самые разные способы самовыражения в виртуальном мире: от создания аватаров и глубокой настройки параметров игры до редакторов ландшафта и настраиваемых мини-игр. Технология Intel® RealSense™ раскрывает новые возможности взаимодействия пользователей с компьютерами. В игре TANKED!, где обычная песочница сочетается с аркадной видеоигрой и дополненной реальностью, эта технология позволяет устраивать увлекательные многопользовательские сражения. Разработчики Design Millв своем решении используют песочнику, технологию Intel RealSense и проектор изображений, чтобы предоставить пользователям возможность собственноручно изменять рельеф игрового пространства, динамически создавать виртуальный мир с помощью обычного песка.

Игра

TANKED!— видеоигра «один на один» в стиле танковой аркады. В начале игры ее участники строят виртуальную среду, используя песок — не виртуальный, а самый обычный. После завершения работы над поверхностью земли в виртуальном пространстве каждого игрока размещается танк, и игра начинается. Игроки управляют перемещением танков по динамически формируемому ландшафту, используя рельеф, чтобы уклоняться от снарядов другого игрока. Танки могут съезжать в долины или подниматься на вершины холмов, чтобы соответствующим образом изменялась траектория выстрелов, при этом танки также собирают бонусы, расположенные в стратегических местах в игре. Эти бонусы достаточно важны: увеличение здоровья, повышение скорости танка или повышение скорострельности пушки может оказаться решающим для победы в игре. Победителем становится игрок, первым нанесший достаточный урон танку своего противника.

Сюжет танкового боя дополнен мини-игрой «Сапер». Игроки получают предупреждение о появлении мин, танки прекращают сражение. Мины размещаются произвольным образом в местах, где, согласно данным с камеры Intel® RealSense™, глубина песка достаточна для размещения мин. Каждый игрок до истечения отведенного времени должен раскопать песок, чтобы найти мины и обезвредить их. Если мина найдена, игрок обезвреживает ее, нажимая свою кнопку действия. Если игрок не успевает найти и обезвредить все мины на своей территории, то его танк получает значительный урон.

Оборудование

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

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

Пакет Intel® RealSense™ SDK используется для получения данных о глубине песка, что позволяет получить совершенно уникальные возможности тактильного управления виртуальным ландшафтом. С помощью Intel RealSense SDK нам удалось откалибровать датчик и проектор, получить данные о глубине песка, сгладить эти данные и исключить недопустимые значений.

На основе данных, полученных от Intel RealSense SDK, динамически формируемый рельеф влияет на траекторию снарядов танков. Если танк находится на склоне холма, то снаряд будет запущен в воздух под большим углом, а не непосредственно вперед. Кроме того, игрок может создавать и песчаные холмы для укрытия. Поэтому каждая игра — уникальна из-за динамически изменяемого рельефа местности: каждый раз игроки заново строят его в песке. Игрокам необходимо учитывать высоту расположения танков в игровом пространстве, сравнивать расстояние до танка противника с дальностью действия пушки своего танка.

Разработка

Камера Intel RealSense наряду с движком Unity* 3D участвует в динамическом создании ландшафта. Поскольку камера Intel RealSense устанавливается непосредственно над столом-песочницей, мы используем COORDINATE_SYSTEM_REAR_OPENCV SETTING для датчика и записываем поток STREAM_TYPE_DEPTH. Для каждого кадра метод Update в Unity вызывает код, который дает камере Intel RealSense команду на передачу данных глубины каждой точки стола-песочницы в Unity. Для повышения производительности показатели глубины, попадающие в приемлемый диапазон, усредняются в Unity для заданного количества кадров. После усреднения значения глубины сглаживаются, поворачиваются, к ним применяются операции сдвига и обрезки при необходимости. После этого значения глубины масштабируются таким образом, чтобы заполнить массив, размер которого равен разрешению heightmapрельефа в Unity. Затем этот массив значений высоты передается в метод TerrainData.SetHeightsв Unity. Настраиваемая карта текстур splatmap, которую мы предоставляем в Unity, обновляется в соответствии с новыми значениями высоты.

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

В ходе мини-игры «Сапер» поверхность земли заново калибруется, поскольку игроки меняют рельеф песка, пытаясь отыскать мины. Это позволяет продемонстрировать возможности динамической работы со средой с помощью камеры Intel RealSense. Игроки могут взаимодействовать со скрытыми мирами и с тайнами в созданном ландшафте.

/// <summary>
/// Gathers depth data from the sensor, adding it to the points you are accumulating for averaging purposes
/// If the number of frames accumulated has reached the number you want to average, the terrain itself if refreshed.
/// </summary>
private void updateTerrain()
{
    if (pp == null || !autoUpdate)
        return;

    pxcmStatus sts = pp.AcquireFrame (false, 0);
    if (sts == pxcmStatus.PXCM_STATUS_NO_ERROR)
{
    PXCMCapture.Sample sample = pp.QuerySample();

    If (sample.depth != null)
{
    cumulativeFramesCount = GetRGB32PixelsDepth2 (sample.depth);
    if (cumulativeFramesCount >= averagePasses)
        cumulativeFramesCount = RefreshData2();
}

pp.ReleaseFrame();
}
else
    pp.ReleaseFrame();
}


/// <summary>
/// Populates the pointsToAverage list with the data from the sensor
/// </summary>
/// <returns> The number of frames accumulated
/// <param name=”image”>Depth sample from the sensor</param>
private int GetRBG32PixelsDepth2 (PXCMImage image)
{
    PCXMImage.ImageData cdata;
    UInt16[] dpixels = null;

    if (image.AcquireAccess(PXCMImage.Access.ACCESS_READ, PXCMImage.PixelFormat.PIXEL_FORMAT_DEPTH, out cdata) >= pxcmStatus.PXCM_STATUS_NO_ERROR)
{
    Int32 dpitch = cdata.pitches[0] / sizeof(Int16);
    Int32 dwidth = (Int32) image.info.width;
    Int32 dheight = (Int32) image.info.height;
    dpixels = cdata.ToShortArray(0, dpitch * dheight);
    image.ReleaseAccess(cdata);
    cumulativeFramesCount += 1;

    float testValue;
    foreach (PointForAveraging point in pointsToAverage)
    {
        //initialize based on the coordinates
        testValue = dpixels[point.heightCoord * dpitch + point.widthCoord];

        if (testValue != depthLowConfidenceValue
        && testValue >= realSenseSettings.MinDepthValue&& testValue <= realSenseSettings.MaxDepthValue)
        {
            point.sumZValues += testValue;
            point.countZValues += 1;
}
}
}

return cumulativeFramesCount;
}

Задачи

Для успешной работы игры важно расположение камеры Intel RealSense и проектора. Камеру Intel RealSense пришлось установить достаточно высоко над песочницей, чтобы в поле зрения камеры попали все четыре стенки песочницу. Мы создали программу для калибровки, которая дает игроку возможность выбрать область внутри стенок песочницы, устанавливая смещения по осям x и y и ширину отображаемой области. С помощью смещений можно указать, должен ли датчик работать в зеркальном режиме, следует ли поворачивать точки глубины на 180 градусов перед их отображением на песке. Эта программа вычисляет высоту отображаемой области на основе выбранной ширины и соотношения сторон камеры Intel RealSense.

Параметры калибровки определяют точки глубины, которые будут использованы в фактической игре. Точки глубины измеряются для каждого кадра в Unity 3D. Для повышения производительности игры значения точек глубины усредняются для заданного количества кадров. Малодостоверные данные датчика глубины и точки глубины, выходящие за пределы заданного диапазона, пропускаются. Вместо всех пропущенных значений глубины используется значение глубины ближайшего допустимого пикселя.

Ландшафт в Unity 3D — это квадратный объект, которым нужно заполнить прямоугольную песочницу. Поэтому перед обновлением значений высоты рельефа нужно применить масштабирование к допустимым точкам глубины, чтобы добиться соответствия с разрешением ландшафта. Для этого используется количество допустимых пикселей по ширине и по глубине пропорционально разрешению heightmap. Масштабированные значения используются для создания массива разрешения heightmap, а затем передаются в метод TerrainData.SetHeights(). После этого текстуры земли и деревьев обновляются на основе этих новых значений высоты. Игрок видит обновленный ландшафт.

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

Перспективы

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

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

Помимо разработки игры TANKED!, мы разработали и перешли к выпуску комплекта разработчиков систем с интерактивным проектором. Этот комплект получил название Torch. С помощью этого комплекта разработчики смогут создавать собственные интерактивные решения с использованием песочниц и поверхности стола. Дополнительные сведения о платформе Torchсм. по адресу www.ExperienceTorch.com.

Инструменты и поддержка Intel®

Документация к Intel RealSense SDK, программа просмотра примеров и образцы кода очень помогли при разработке TANKED!. В примерах «Raw Streams» и «Capture Viewer» были представлены потоки цветного изображения, данных глубины и данных ИК-датчика с камеры Intel RealSense при различных габаритах сцены и при разной кадровой скорости. Эти примеры помогли нам определить, что именно должно попадать в поле зрения камеры, и мы воспользовались этой информацией в игре. Примеры кода Unity и C# в составе SDK оказались исключительно полезными в качестве отправной точки для разработки. Для получения дополнительных инструментов и ресурсов для создания игры мы использовали портал Intel Developer Zone, нам оказывали личную поддержку члены команды разработчиков технологии Intel RealSense, мы получили помощь от сообщества и службы поддержки игрового движка Unity.

О компании Design Mill (www.designmillinc.com)

Design Mill, Inc. — стратегический системный интегратор, создающий передовые решения для ведущих отраслевых организаций и Министерства обороны США. В решениях Design Mill применяется интеграция современного интерактивного оборудования и программного обеспечения, используются самые передовые методики и процессы проектирования и разработки. Компания Design Mill занимается разработкой новейших решений в области виртуальной и дополненной реальности. Мы помогаем клиентам раскрывать самые передовые подходы взаимодействия с потребителями и развивать стратегии для достижения успеха на новом уровне.

Примечания

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

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

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

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

Копии документов с порядковым номером, ссылки на которые приведены в этом документе или в другой документации Intel, можно получить, обратившись по телефону 1-800-548-47-25 или на сайте www.intel.com/design/literature.htm.

Intel, эмблема Intel и RealSense являются товарными знаками корпорации Intel в США и в других странах.

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

© Intel Corporation, 2015 г.

Пример исходного кода распространяется на условиях лицензионного соглашения корпорации Intel на использование образцов исходного кода.

Базовые сведения

Для быстрой обработки пакетов требуется обнаруживать битовые шаблоны и быстро (со скоростью работы канала) принимать решения о нужных действиях на основе наличных битовых шаблонов. Эти битовые шаблоны могут принадлежать одному из нескольких заголовков, присутствующих в пакете, которые, в свою очередь, могут находиться на одном из нескольких уровней, например Ethernet, VLAN, IP, MPLS или TCP/UDP. Действия, определяемые по битовым шаблонам, могут различаться — от простого перенаправления пакетов в другой порт до сложных операций перезаписи, для которых требуется сопоставление заголовка пакета из одного набора протоколов с другими. К этому следует добавить функции управления трафика и политик трафика, брандмауэры, виртуальные частные сети и т. п., вследствие чего сложность операций, которые необходимо выполнять с каждым пакетом, многократно возрастает.

Чтобы добиться работы на ожидаемом уровне производительности при скорости канала 10 Гбит/с и размере пакета в 84 байта, процессор должен обрабатывать 14,88 миллиона пакетов в секунду. Оборудование общего назначения было недостаточно мощным для обработки пакетов с такой скоростью. Поэтому в большинстве рабочих сетевых систем обработкой пакетов в каналах данных занимаются контроллеры ASIC и сетевые процессоры NPU. К очевидным недостаткам такого подхода относятся: недостаточная гибкость, высокая стоимость, длительные циклы разработки, зависимость от определенного поставщика. Тем не менее, благодаря доступности более быстрых и дешевых ЦП и программных ускорителей, таких как Data Plane Development Kit (DPDK), можно переложить эту нагрузку на оборудование общего назначения.

Что такое Data Plane Development Kit?

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

DPDK обычно работает под управлением Linux*, хотя существует версия некоторых компонентов DPDK для FreeBSD*. DPDK — это проект с открытым исходным кодом, распространяющийся по лицензии BSD. Самые поздние исправления и дополнения, предоставленные сообществом, доступны в основной ветви.

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

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

DPDK дает возможность:

• принимать и отправлять пакеты с использованием наименьшего количества циклов ЦП (обычно не более 80 циклов);
• разрабатывать алгоритмы быстрой записи пакетов (наподобие tcpdump);
• запускать быстрые стеки сторонних разработчиков.

Производительность некоторых функций обработки пакетов составляет миллионы кадров в секунду при использовании 64-байтовых пакетов с сетевыми платами PCIe*.

Использование Data Plane Development Kit

Чтобы приступить к работе с DPDK, выполните следующие действия:

1. Если у вас нет Linux, загрузите virtual box и установите машину Linux.
2. Загрузите последнюю версию DPDK с помощью одной из команд в зависимости от используемого ядра Linux.
   wget www.dpdk.org/browse/dpdk/snapshot/dpdk-2.1.0.tar.gz
   или
   sudo apt-get www.dpdk.org/browse/dpdk/snapshot/dpdk-2.1.0.tar.gz
   или
   yum install www.dpdk.org/browse/dpdk/snapshot/dpdk-2.1.0.tar.gz
3. Распакуйте ZIP-файл DPDK.
   tar zxvf dpdk-2.1.0.tar.gz

4. Изучите исходный код.
   cd dpdk-2.1.0
   Чтобы ознакомиться с содержанием каталогов, посмотрите видео Глава 1: структура каталогов DPDK, сценарии и настройка DPDKв курсе Network Builder University Введение в DPDK.

5. Проверьте конфигурацию ЦП.
   cd tools
./cpu_layout.py
   
   Образец вывода
   
6. Проверьте конфигурацию сетевых адаптеров.
   
   stack@nde01 tools]$ ./dpdk_nic_bind.py --status
   Network devices using DPDK-compatible driver
   ============================================
0000:03:00.0 'Ethernet Connection X552/X557-AT 10GBASE-T' drv=igb_uio unused=
0000:03:00.1 'Ethernet Connection X552/X557-AT 10GBASE-T' drv=igb_uio unused=
   Network devices using kernel driver
   ===================================
0000:05:00.0 'Ethernet Controller XL710 for 40GbE QSFP+' if=ens2f0 drv=i40e unused=igb_uio
0000:05:00.1 'Ethernet Controller XL710 for 40GbE QSFP+' if=ens2f1 drv=i40e unused=igb_uio
0000:07:00.0 'I350 Gigabit Network Connection' if=eno1 drv=igb unused=igb_uio *Active*
0000:07:00.1 'I350 Gigabit Network Connection' if=eno2 drv=igb unused=igb_uio
   
   Other network devices
   =====================
<none>
7. Настройте DPDK:
   setup.sh — полезная программа, помогающая скомпилировать DPDK и настроить систему. Для запуска этой программы нужны права root. В каталоге tools введите:
   
   ./setup.sh
   
   В результате вы получите примерно следующее:
   
   [stack@nde01 tools]$ ./setup.sh
------------------------------------------------------------------------------
RTE_SDK exported as /admin/software_installfiles/dpdk-2.1.0
------------------------------------------------------------------------------
----------------------------------------------------------
Step 1: Select the DPDK environment to build
----------------------------------------------------------
[1] i686-native-linuxapp-gcc
[2] i686-native-linuxapp-icc
[3] ppc_64-power8-linuxapp-gcc
[4] tile-tilegx-linuxapp-gcc
[5] x86_64-ivshmem-linuxapp-gcc
[6] x86_64-ivshmem-linuxapp-icc
[7] x86_64-native-bsdapp-clang
[8] x86_64-native-bsdapp-gcc
[9] x86_64-native-linuxapp-clang
[10] x86_64-native-linuxapp-gcc
[11] x86_64-native-linuxapp-icc
[12] x86_x32-native-linuxapp-gcc

----------------------------------------------------------
Step 2: Setup linuxapp environment
----------------------------------------------------------
[13] Insert IGB UIO module
[14] Insert VFIO module
[15] Insert KNI module
[16] Setup hugepage mappings for non-NUMA systems
[17] Setup hugepage mappings for NUMA systems
[18] Display current Ethernet device settings
[19] Bind Ethernet device to IGB UIO module
[20] Bind Ethernet device to VFIO module
[21] Setup VFIO permissions

----------------------------------------------------------
Step 3: Run test application for linuxapp environment
----------------------------------------------------------
[22] Run test application ($RTE_TARGET/app/test)
[23] Run testpmd application in interactive mode ($RTE_TARGET/app/testpmd)

----------------------------------------------------------
Step 4: Other tools
----------------------------------------------------------
[24] List hugepage info from /proc/meminfo
----------------------------------------------------------
Step 5: Uninstall and system cleanup
----------------------------------------------------------
[25] Uninstall all targets
[26] Unbind NICs from IGB UIO or VFIO driver
[27] Remove IGB UIO module
[28] Remove VFIO module
[29] Remove KNI module
[30] Remove hugepage mappings

[31] Exit Script
Option:

   Нужно выбрать параметр и настроить.

   1. На шаге 1 требуется выбрать сборку среды DPDK. Можно выбрать x86_64-native-linuxapp-gcc; это вариант 10.
   2. На шаге 2 нужно настроить среду приложения Linux.Параметр 13— загрузка последней версии модуля IGB UIO и компиляция последней версии драйвера IGB UIO. IGB UIO — это модуль ядра DPDK, работающий с перечислением PCI и обрабатывающий прерывания состояния ссылок в пользовательском режиме (вместо ядра). Также требуется поддержка выделения сверхкрупных страниц, например страниц 2 МБ для NUMA, параметр 17. Параметр 18— отображение текущих параметров Ethernet, как на шаге 6 выше. С помощью параметра 19,удалите привязку нужного сетевого адаптера от драйвера ядра Linux и привяжите его к установленному модулю IGB UIO с помощью параметра 13.

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

   Сведения об установке см. в видеоролике Глава 2: настройка DPDKв составе курса Network Builder University Введение в DPDK.

8. Скомпилируйте образец приложения l2fwd. Это приложение перенаправления уровня 2, оно перенаправляет пакеты на основе MAC-адресов, а не IP-адресов.

   cd examples
cd l2fwd
export RTE_SDK=<папка установки dpdk>
make
9. Запустите образец приложения.
   
   Синтаксис: ./build/l2fwd -c COREMASK|-l CORELIST -n CHANNELS [options]

./build/l2fwd –c 0x3 –n 4 -- -p 0x3
   -c (шестнадцатеричная битовая маска ядер, нужно запустить одно)
   , например –c Ox3означает запуск на обоих ядрах, поскольку двоичное 11 = 0x3
   
   -n (количество каналов памяти)
   , например –n 4означает запуск на всех четырех каналах, доступных на процессоре Intel Xeon
   
   -p (маска порта)
   -p 0x3означает запуск на обоих портах, привязанных к dpdk, поскольку двоичное 11 = 0x3  

   В нашем тестировании этот образец приложения перенаправляет все пакеты, поступающие на порт 0, в порт 1 и наоборот. После запуска он переключается в цикл опрашивания, где опрашивает оба порта и обновляет статистику, например количество принятых и отправленных пакетов, каждые 10 секунд (см. на последнем снимке экрана ниже). На первом снимке экрана показан уровень EAL (уровень абстракции среды), проходящий через все логические ядра, которые связаны с физическими ядрами. На втором снимке экрана показаны устройства PCI/сетевые карты, привязанные к DPDK (драйвер IGB UIO, см. шаги 7 -> 2 выше) и использующие по этой причине драйвер rte_ixgbe_pmd (это драйвер опрашиваемого режима DPDK), а также сетевые карты, не находящиеся под управлением DPDK. На снимке экрана 3 показано одно логическое ядро, выделенное для каждого физического порта.

   
   
   

Подробные сведения о вариантах выполнения см. в разделе Глава 3: компиляция и запуск образца приложенияв курсе Network Builder University Введение в DPDK.

В образце приложения показана базовая функциональность перенаправления уровня 2. Если нужно измерить производительность DPDK, ознакомьтесь с курсом Intel Network Builder University Использование DPPD PROX, в котором Люк Провост, технический руководитель отдела Network Platforms Group корпорации Intel, измеряет производительность виртуальной сети с помощью DPPD (Data Plane Performance Demonstrator) Prox, чтобы помочь разработчикам программного обеспечения понять и использовать эти инструменты.

Заключение

DPDK — программный ускоритель, работающий в пользовательском пространстве в обход ядра Linux и предоставляющий доступ к сетевым адаптерам, ЦП и памяти для приложений, обрабатывающих пакеты. В этой статье приводится пошаговая инструкция по загрузке DPDK 2.1.0 на платформе Linux с компиляцией, настройкой и запуском образца приложения.

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

• DPDK 101. В этом курсе Intel Network Builders University Эндрю Дигнан, инженер по приложениям для платформ в корпорации Intel, рассказывает о DPDK (на основе версии 2.1), в том числе о лицензировании, принципах обработки пакетов, библиотеках компонентов DPDK, проблемах с памятью в архитектуре Intel® и о настройке DPDK с точки зрения работы с памятью.

• DPDK 201. В этом курсе Intel Network Builders University MJay, ведущий инженер по платформам в корпорации Intel, рассказывает о DPDK и описывает концепцию устройства DPDK (на основе версии 2.1), основные компоненты и причины их создания, а затем рассказывает о том, как разрабатывались образцы приложений.

• Руководство для программистов DPDK на сайте DPDK.org.

Есть вопрос? Задайте его на форуме SDN/NFV.

Об авторе

Суджата Тибервала (Sujata Tibrewala) — менеджер сетевого сообщества и разработчик-евангелист в корпорации Intel. Она занималась разработкой сетевого программного обеспечения, а сейчас занимается технологиями, предназначенными для оптимизации распространенного сетевого оборудования с использованием SDN и NFV.

Пример кода

В первом за этот год выпуске (2016 R1, т. е. v8) пакета Intel® RealSense™ SDKреализован целый ряд усовершенствований, но меня больше всего заинтересовал интерфейс JavaScript, в частности насколько быстро удастся использовать данные трехмерной камеры для веб-игр. Боб Даффи (Bob Duffy) написал подробную статьюоб этом, но кое-что изменилось, а мне хотелось бы использовать как можно меньше кода, чтобы опробовать этот подход (это позволит применить тестовый код, предназначенный для проверки концепции, к более крупным системам).

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

Начало работы

Сначала необходимо подготовить следующее.

• Камера Intel® RealSense™: установите последнюю версию Intel® RealSense™ Depth Camera Manager (DCM)для вашей камеры.
• Intel RealSense SDK: загрузите последнюю версию SDK.
• Исполняемый модуль веб-приложений: загрузите и установите последнюю версию (в настоящее время это v8), затем перезапустите браузер.

• Расположение файла: для удобства скопируйте файл realsense.js из файловой структуры SDK на рабочий стол. При установке текущей версии в папку по умолчанию это C:\Program Files (x86)\Intel\RSSDK\framework\common\JavaScript\.
• Текстовый редактор: можно использовать практически любой редактор.
• Создание файла: создайте новый HTML-файл в том же месте, где находится файл realsense.js.
• Содержание: скопируйте приведенный ниже пример кода в созданный файл или (желательно) заново вводите его по мере того, как мы будем разбирать его в этой статье.

Пример кода

Для иллюстрации простоты поставленной задачи ниже приводится полный исходный код (исключая комментарий с отказом от гарантий). 

<!doctype HTML><html><head><title>RS-JS Face Tracking</title><script type="text/javascript" src="https://autobahn.s3.amazonaws.com/autobahnjs/latest/autobahn.min.jgz"></script><script src="realsense.js"></script></head><body><canvas id="mainCanvas" width=600 height=400 style="border:1px solid black"></canvas><script>
			var can = document.getElementById("mainCanvas");
			var ctx = can.getContext("2d");
			ctx.textAlign = "center"; // Set text to be centered at draw point
			var scale = 500; // Scale nose point movement to significance

			var rsf = intel.realsense.face;
			var sm, fm, fc; // Sense Manager, Face Module, Face Config

			var onFaceData = function(sender,data) {
				if (data.faces.length>0) { //Ignore empty screens
					var face = data.faces[0]; // Use first face visible
					var rect = face.detection.boundingRect; // Get face bounding box
					var n = face.landmarks.points[29].world; // Get face landmark data

					var px = rect.x + rect.w/2 + n.x*scale; // Anchor to bounding box
					var py = rect.y + rect.h/2 - n.y*scale;	// Invert y-axis shift

					ctx.clearRect(0,0,can.width,can.height); // Clear canvas each frame
					ctx.strokeRect(rect.x,rect.y,rect.w,rect.h); // Show bounding box
					ctx.fillText(Math.round(n.z*100),px,py); // draw z value at nose point
				}
			}

			intel.realsense.SenseManager.createInstance().then(function (instance){
				sm = instance;
				return rsf.FaceModule.activate(sm); // Activate face module
			}).then(function (instance) {
				fm = instance;
				fm.onFrameProcessed = onFaceData; // Set face data handler
				return fm.createActiveConfiguration(); // Configure face tracking
			}).then(function (instance) {
				fc = instance;
				fc.detection.isEnabled = true; // Enable face detection
				return fc.applyChanges();
			}).then(function (result) {
				fc.release()
				return sm.init(); // Sense manager initialization
			}).then(function (result) {
				return sm.streamFrames(); // Start Streaming
			});

			window.onblur=function(){ // Pause face module when window loses focus
				if(fm != undefined){
					fm.pause(true);
				}
			}
			window.onfocus=function(){ // Unpause face module when window regains focus
				if(fm != undefined){
					sm.captureManager.device.restorePropertiesUponFocus();
					fm.pause(false);
				}
			}
			window.beforeunload = function(){ // Release sense manager on window close
				if(sm != undefined){
					sm.release().then(function(){
						sm=fm=undefined;
					});
				}
			}
		</script></body></html>

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

Разделение по функциям

Раздел HTML

<!doctype HTML><html><head><title>RS-JS Face Tracking</title><script type="text/javascript" src="https://autobahn.s3.amazonaws.com/autobahnjs/latest/autobahn.min.jgz"></script><script src="realsense.js"></script></head><body><canvas id="mainCanvas" width=600 height=400 style="border:1px solid black"></canvas><script>…
		</script></body></html>

Это в буквальном смысле весь код HTML, находящийся на странице. Добавление сценария autobahn крайне важно для выполнения технической работы, благодаря которой SDK получает возможность работать с камерой из браузера посредством другого добавленного файла (realsense.js), скопированного ранее.

Единственный настоящий элемент, отображаемый на этой странице, — canvas, оно здесь обозначено произвольным образом для отображения данных по мере их получения. Дополнительные сведения об основах этого подхода см. на сайте IDZ.

Оставшаяся часть кода попадает в третий тег script. В идеале следовало бы разместить ее в заголовке, но она находится в конце для упрощения некоторых процедур загрузки. Примечание. Это (как и приведенная выше ссылка на IDZ) — еще один пример JavaScript в стиле хакатона, код по своему устройству пригоден только для демонстрации. Доработав его для выполнения ваших задач, сохраните функциональные фрагменты в более масштабируемой и подходящей структуре.

Переменные и использование

var can = document.getElementById("mainCanvas");
var ctx = can.getContext("2d");
ctx.textAlign = "center"; // Выравнивание текста по центру относительно точки рисования
var scale = 500; // Масштабирование движения точки носа

var rsf = intel.realsense.face;
var sm, fm, fc; // Sense Manager, модуль Face, настройка лица

var onFaceData = function(sender,data) {
…
}

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

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

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

Инициализация камеры Intel® RealSense™

intel.realsense.SenseManager.createInstance().then(function (instance){
	sm = instance;
	return rsf.FaceModule.activate(sm); // Включение модуля Face
}).then(function (instance) {
	fm = instance;
	fm.onFrameProcessed = onFaceData; // Задание обработчика данных лица
	return fm.createActiveConfiguration(); // Настройка отслеживания лица
}).then(function (instance) {
	fc = instance;
	fc.detection.isEnabled = true; // Включение обнаружения лица
	return fc.applyChanges();
}).then(function (result) {
	fc.release();
	return sm.init(); // Инициализация Sense Manager
}).then(function (result) {
	return sm.streamFrames(); // Запуск передачи
});

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

1. Создайте Sense Manager, сохраненный как sm.
2. С помощью sm включите модуль Face, сохраненный в fm.
3. Задайте наш обработчик данных и используйте fm, чтобы создать активную конфигурацию лица fc.
4. Включите обнаружение лиц в fc, затем высвободите его (поскольку больше не требуется вносить изменения в настройку).
5. Теперь можно инициализировать sm и приступить к записи данных.

Вот и весь процесс инициализации. Для других модулей используется аналогичный подход.

Обработка камеры

window.onblur=function(){ // Приостановка модуля Face, когда окно теряет фокус ввода
	if(fm != undefined){
		fm.pause(true);
	}
}
window.onfocus=function(){ // Возобновление работы модуля Face, когда окно снова получает фокус ввода
	if(fm != undefined){
		sm.captureManager.device.restorePropertiesUponFocus();
		fm.pause(false);
	}
}
window.beforeunload = function(){ // Высвобождение Sense Manager при закрытии окна
	if(sm != undefined){
		sm.release().then(function(){
			sm=fm=undefined;
		});
	}
}

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

Обработка данных

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

Рисунок 1:Индекс каждой реперной точки отображается в ее расположении на лице

var onFaceData = function(sender,data) {
	if (data.faces.length>0) { // Пропуск пустых экранов
		var face = data.faces[0]; // Использование первого видимого лица
		var rect = face.detection.boundingRect; // Получение ограничительной рамки лица
		var n = face.landmarks.points[29].world; // Получение данных реперов лица

		var px = rect.x + rect.w/2 + n.x*scale; // Привязка к ограничительной рамке
		var py = rect.y + rect.h/2 - n.y*scale;	// Зеркальное отражение сдвига по оси Y

		ctx.clearRect(0,0,can.width,can.height); // Очистка полотна в каждом кадре
		ctx.strokeRect(rect.x,rect.y,rect.w,rect.h); // Отображение ограничительной рамки
		ctx.fillText(Math.round(n.z*100),px,py); // Отображение значения z в точке носа
	}
}

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

Переменные px и py образуют расположение выбранной для представления точки носа в нашем пространстве: перемещение носа вычисляется на основе центральной точки ограничительной рамки, масштабируется и сохраняется с новыми координатами X и Y.

Эти переменные дают нам расположение для изображения значения Z точки носа — глубины, то есть расстояния от экрана (для удобочитаемости оно умножено на 100, поскольку необработанное значение нормализуется до десятичной дроби в диапазоне от 0 до 1). Точка носа и ограничительная рамка отображаются на полотне после его очистки.

Дальнейшие действия

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

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

Справочные материалы

Документация к Intel® RealSense™ SDK 2016 R1: https://software.intel.com/sites/landingpage/realsense/camera-sdk/v1.1/documentation/html/index.html?doc_face_face_tracking_and_recognition.html

Intel® RealSense™ Depth Camera Manager (DCM): https://downloadcenter.intel.com/download/25044/Intel-RealSense-Depth-Camera-Manager-DCM-

Intel® RealSense™ SDK: https://software.intel.com/en-us/intel-realsense-sdk/download

RealSense — ваше лицо в качестве игрового контроллера при использовании Javascript: https://software.intel.com/en-us/blogs/2014/12/08/realsense-your-face-as-a-controller-using-javascript?language=en

Новые возможности Intel RealSense SDK v8 (2016 R1) для Windows: https://software.intel.com/en-us/blogs/2016/01/28/new-realsense-v8

Об авторе

Брэд Хилл (Brad Hill) — инженер по программному обеспечению в подразделении Developer Relations корпорации Intel. Брэд занимается изучением новых технологий на оборудовании Intel® и обменивается лучшими методиками с разработчиками ПО на форумах Intel® Developer Zone и на конференциях разработчиков. Он помогает студентам и разработчикам становиться разработчиками игр и изменять мир к лучшему.

Введение

Камера SR300 — камера переднего обзора Intel® RealSense™ второго поколения, поддерживающая операционную систему Microsoft Windows* 10. Как и в камере F200, в модели SR300 используется технология цветового кодирования глубины для создания высококачественного трехмерного видеопотока глубины на небольшом расстоянии. Камера SR300 включает источник инфракрасной (ИК) подсветки, высокоскоростную ИК-камеру с разрешением VGA и обычную цветную двухмегапиксельную камеру со встроенным цифровым процессором изображений. В модели SR300 для съемки глубины используется высокоскоростной режим VGA вместо обычного режима VGA, который применялся в модели F200. В новом режиме съемки глубины снижено время экспозиции, поддерживается динамическое движение со скоростью до 2 м/с. Такая камера открывает новые способы использования платформы за счет предоставления синхронизированных данных цветного изображения, глубины и ИК-видео в клиентскую систему. Эффективная дальность распознавания глубины составляет от 0,2 до 1,2 м, это оптимальные значения для использования в помещениях.

Рисунок 1:Камера SR300

Камера SR300 может использовать Intel® RealSense™ SDKдля Windows. Поддержка камеры SR300 реализована в SDK версии 2015 R5 или более поздней. Камера SR300 будет поставляться в 2016 году как в виде автономного устройства, так и встраиваться в различные устройства, включая ПК, моноблоки, ноутбуки и трансформеры. В модели SR300 реализованы новые и усовершенствованные возможности по сравнению с F200.

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

* По данным на 19 февраля 2016 г.

Новые возможности, поддерживаемые только камерой SR300

Режим Cursor

Отличительная особенность камеры SR300 — режим Cursor. Этот режим отслеживания возвращает единственную точку для руки, что позволяет очень точно отслеживать трехмерное положение указателя и выполнять основные жесты. В режиме Cursor производительность повышена более чем на 50 % по сравнению с режимом отслеживания всей кисти, но при этом отсутствуют задержки и не требуется калибровка. Дальность увеличена до 85 см, а допустимая скорость движения — до 2 м/с. В режиме Cursor поддерживается жест щелчка, имитирующий щелчок мыши указательным пальцем.

Рисунок 2:Жест щелчка

Отслеживание человека

Еще одна новая функция модели SR300 — отслеживание человека. Этот режим также поддерживается камерой заднего обзора R200, но недоступен для камеры F200. В этом режиме происходит отслеживание трехмерного движения тела в реальном времени. Поддерживается три основных режима отслеживания: движение тела, суставы скелета, распознавание лиц.

• Движение тела: обнаружение тела, контура головы и туловища.
• Суставы скелета: возвращает расположение суставов человеческого тела в двухмерных и трехмерных данных.
• Распознавание лиц: сравнение текущего лица с базой данных зарегистрированных пользователей для идентификации пользователя.

Повышенная дальность и боковая скорость

В камерах SR300 появился новый режим съемки глубины — ускоренный VGA. В этом режиме съемка происходит с половинным разрешением VGA, а отснятые кадры интерполируются до полного разрешения VGA перед передачей клиенту. В этом новом режиме глубины снижено время экспозиции и поддерживается скорость движения руки до 2 м/с, тогда как в камерах F200 с обычным режимом VGA допустимая скорость движения не должна была превышать 0,75 м/с. В модели SR300 также повышена дальность действия по сравнению с F200. В режиме отслеживания рук дальность действия камеры SR300 увеличена до 85 см (по сравнению с 60 см у камеры F200). Дальность сегментации рук увеличена до 110 см у камеры SR300 по сравнению со 100 см у камеры F200.

Дальность распознавания лица увеличена с 80 см у камеры F200 до 150 см у камеры SR300.

В модели SR300 улучшено наложение цветных текстур и достигается более точное трехмерное сканирование. Дальность трехмерного сканирования увеличена до 70 см, при этом также повышена детализация. В режиме отслеживания Blob скорость отслеживания увеличена до 2 м/с, а дальность — до 150 см.

Дальность съемки глубины увеличена у камеры SR300 на 50–60 %. На расстоянии 80 см обе камеры (и SR300, и F200) четко обнаруживают руки. При увеличении расстояния свыше 120 см камера SR300 по-прежнему обнаруживает руки, а камера F200 уже не может распознать их.

Рисунок 3:Дальность датчиков глубины камер SR300 и F200

Повышенное качество цветопередачи при съемке с недостаточным освещением, улучшенные трехмерные текстуры для трехмерного сканирования

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

Улучшенная синхронизация потоков цветного изображения и глубины

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

Пониженное потребление электроэнергии

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

Обратная совместимость с приложениями для камеры F200

Intel RealSense Depth Camera Manager (DCM) 3.x дает возможность камере SR300 работать в качестве камеры F200, обеспечивая обратную совместимость для приложений, разработанных для камеры F200. DCM имитирует ресурсы камеры F200, поэтому все существующие приложения SDK будут работать и с камерой SR300. Возможности камеры SR300 поддерживаются в SDK R5 2015 или более поздней версии.

Когда запрос на поточную передачу поступает от приложения SDK, скомпилированного в SDK версии до R5 2015, DCM автоматически задействует режим совместимости и будет отправлять вызовы через конвейер F200 вместо SR300. Большинство приложений будут работать с новой камерой SR300 без каких-либо изменений настройки.

Совместимость инфракрасных данных

Камера SR300 поддерживает 10-разрядный формат данных инфракрасного изображения, тогда как F200 поддерживает 8-разрядный формат таких данных. Драйвер DCM обеспечивает совместимость, добавляя или удаляя 2 разряда к данным для получения нужного формата.

Физический разъем

Устройство материнской платы и кабелей у камер F200 и SR300 идентично. Кабель камеры F200 можно подключить в разъем камеры SR300. Поэтому для камер SR300 можно использовать кабель от камер F200. Для обеих моделей требуется интерфейс USB 3.0.

API SDK

Большинство API SDK являются общими для камер SR300, F200 и даже R200 (в некоторых случаях). Модули SDK предоставляют соответствующий интерфейс, в зависимости от того, какая модель камеры была обнаружена во время выполнения. Аналогичным образом простая передача потоков цветного изображения и глубины, где не требуется определенное изображение или определенный формат пикселей, будет работать без каких-либо изменений.

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

Поскольку все описанные параметры автоматически изменяются в зависимости от камеры, важно, чтобы каждое приложение проверяло модель камеры и ее конфигурацию во время выполнения. См. раздел «Настройки установщика» в документации SDK.

DCM

На момент написания этой статьи для SR300 доступна «золотая» версия DCM 3.0.24.59748, а обновления будут распространяться с помощью Центра обновления Windows. Посетите сайт https://software.intel.com/en-us/intel-realsense-sdk/downloadдля получения последней версии DCM. Дополнительные сведения о DCM см. в разделе Обзор камер Intel® RealSenseTM и DCM.

Требования к оборудованию

Для поддержки пропускной способности, необходимой камере Intel RealSense, в клиентской системе должен быть порт USB 3. Подробные сведения о требованиях к системе и о поддерживаемых операционных системах для камер SR300 и F200 см. по адресу https://software.intel.com/en-us/RealSense/Devkit/

Заключение

В этом документе описываются новые и улучшенные возможности камеры переднего обзора Intel RealSense 3D SR300 по сравнению с возможностями камеры F200. Эти новые возможности поддерживаются в SDK 2015 R5 и DCM 3.0.24.51819 или более поздней версии. Новую камеру можно заказать по адресу http://click.intel.com/realsense.html.

Справочные материалы

Вот несколько полезных ссылок на Intel® RealSense™ DCM и SDK, включая заметки к выпускам и инструкции по установке и обновлению программного обеспечения.

• Developer Zone:
  https://software.intel.com/en-us/realsense/home
  https://software.intel.com/en-us/forums/realsense
• F200
  https://software.intel.com/en-us/articles/realsense-r200-camera
• DCM:
  https://software.intel.com/en-us/blogs/2015/10/18/intel-realsense-depth-camera-manager-dcm-overview?wapkw=DCM%20overview
• SDK
  https://software.intel.com/en-us/blogs/2016/01/28/new-realsense-v8

Об авторе

Нэнси Ле (Nancy Le) — инженер по программному обеспечению в подразделении Software and Services Group корпорации Intel. Она работает над проектами по масштабированию с процессорами Intel® Atom™.

Введение

Процессоры Intel® Core™ 6-го поколения (Skylake) появились в 2015 году. Благодаря целому ряду усовершенствований на уровне ядра, «системы на кристалле» и на уровне платформы, по сравнению с 14-нм процессором предыдущего поколения (Broadwell), процессор Skylake пользуется огромной популярностью в устройствах самых разных типов, предназначенных для работы, творчества и игр. В этой статье приводится обзор основных возможностей и усовершенствований Skylake, а также новые модели использования, такие как пробуждение по голосовым командам и вход в систему по биометрическим данным в ОС Windows* 10.

Архитектура Skylake

Процессоры Intel Core 6-го поколения производятся по 14-нм технологии с учетом более компактного размера процессора и всей платформы для использования в устройствах разных типов. При этом также повышена производительность архитектуры и графики, реализованы расширенные средства безопасности. На рис. 1 показаны эти новые и улучшенные возможности. Фактическая конфигурация в устройствах ОЕМ-производителей может различаться.

Рисунок 1.Архитектура Skylake и сводка усовершенствований [1].

Основные направления развития процессоров

Производительность

Повышение производительности напрямую обусловлено предоставлением большего количества инструкций исполняющему блоку: за каждый тактовый цикл выполняется больше инструкций. Такой результат достигается за счет улучшений в четырех категориях [Ibid].

• Улучшенный внешний интерфейс. Благодаря более точному предсказанию ветвления и повышенной вместимости увеличивается скорость декодирования инструкций, упреждающая выборка работает быстрее и эффективнее.
• Улучшенное распараллеливание инструкций. За каждый такт обрабатывается больше инструкций, при этом параллельное выполнение инструкции улучшено благодаря более эффективной буферизации.
• Улучшенные исполняющие блоки (ИБ). Работа исполняющих блоков улучшена по сравнению с прежними поколениями за счет следующих мер:
  • Укорочены задержки.
  • Увеличено количество ИБ.
  • Повышена эффективность электропитания за счет отключения неиспользуемых блоков.
  • Повышена скорость выполнения алгоритмов безопасности.
• Улучшенная подсистема памяти. В дополнение к улучшению внешнего интерфейса, параллельной обработке инструкций и исполняющих блоков усовершенствована и подсистема памяти в соответствии с пропускной способностью и требованиями производительности перечисленных выше компонентов. Для этого использованы следующие меры:
  • Повышенная пропускная способность загрузки и сохранения.
  • Улучшенный модуль упреждающей выборки.
  • Хранение на более глубоком уровне.
  • Буферы заполнения и обратной записи.
  • Улучшенная обработка промахов страниц.
  • Повышенная пропускная способность при промахах кэша второго уровня.
  • Новые инструкции управления кэшем.

Рисунок 2.Схема микроархитектуры ядра Skylake

На рис. 3 показано улучшение параллельной обработки в процессорах Skylake по сравнению с процессорами прежних поколений (Sandy Bridge — второе, а Haswell — четвертое поколение процессоров Intel® Core™).

Рисунок 3.Улучшенное распараллеливание по сравнению с прежними поколениями процессоров

Благодаря усовершенствованиям, показанным на рис. 3, производительность процессора возросла на 60 % по сравнению с ПК пятилетней давности, при этом перекодирование видео осуществляется в 6 раз быстрее, а производительность графической подсистемы выросла в 11 раз.

Рисунок 4.Производительность процессора Intel® Core™ 6-го поколения по сравнению с ПК пятилетней давности

1. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте SYSmark* 2014.
2. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте Handbrake с QSV.
3. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i5-6500 и Intel® Core™ i5-650 в тесте 3DMark* Cloud Gate.

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

Производительность настольных компьютеров: http://www.intel.com/content/www/us/en/benchmarks/desktop/6th-gen-core-i5-6500.html

Производительность ноутбуков: http://www.intel.com/content/www/us/en/benchmarks/laptop/6th-gen-core-i5-6200u.html

Экономия электроэнергии

Настройка ресурсов на основе динамического потребления

В устаревших системах используется технология Intel® SpeedStep® для балансировки производительности и расхода электроэнергии с помощью алгоритма подключения ресурсов по запросу. Этот алгоритм управляется операционной системой. Такой подход неплох для постоянной нагрузки, но неоптимален при резком повышении нагрузки. В процессорах Skylake технология Intel® Speed Shift передает управление оборудованию вместо операционной системы и дает возможность процессору перейти на максимальную тактовую частоту примерно за 1 мс, обеспечивая более точное управление электропитанием[3].

Рисунок 5.Сравнение технологий Intel® Speed Shift и Intel® SpeedStep®

На приведенном ниже графике показана скорость реагирования процессора Intel® Core™ i5 6200U с технологией Intel Speed Shift по сравнению с технологией Intel SpeedStep.

• Скорость реагирования выросла на 45 %.
• Обработка фотографий на 45 % быстрее.
• Построение графиков на 31 % быстрее.
• Локальные заметки на 22 % быстрее.
• Средняя скорость реагирования выросла на 20 %.

[Согласно результатам теста WebXPRT* 2015 компании Principled Technologies*, в котором измеряется производительность веб-приложений в целом и в отдельных областях, таких как обработка фотографий, создание заметок, построение графиков. Дополнительные сведения см. на сайте www.principledtechnologies.com.]

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

Мультимедиа и графика

Видеоадаптер Intel® HD Graphics воплощает целый ряд усовершенствований с точки зрения обработки трехмерной графики, обработки мультимедиа, вывода изображения на экран, производительности, электропитания, возможности настройки и масштабирования. Это весьма мощное устройство в семействе встроенных в процессор графических адаптеров (впервые появившихся в процессорах Intel® Core™ второго поколения). На рис. 6 сравниваются некоторые из этих усовершенствований, обеспечивающих повышение производительности графики более чем в 100 раз[2].

[Пиковое значение FLOPS шейдера при частоте 1 ГГц]

Рисунок 6.Возможности графической подсистемы в разных поколениях процессоров

Рисунок 7.Улучшение обработки графики и мультимедиа в разных поколениях

Микроархитектура 9-го поколения

Графическая архитектура 9-го поколения аналогична микроархитектуре графики 8-го поколения процессоров Intel® Core™ Broadwell (5-го поколения), но улучшена с точки зрения производительности и масштабируемости. На рис. 8 показана блок-схема микроархитектуры поколения 9[8], состоящей из трех основных компонентов.

• Экран.С левой стороны.
• Вне среза. L-образная часть в середине. Включает поточный обработчик команд, глобальный диспетчер потоков и графический интерфейс (GTI).
• Срез.Включает исполняющие блоки (ИБ).

По сравнению с 8-м поколением микроархитектура 9-го поколения отличается более высокой максимальной производительностью на 1 Вт, повышенной пропускной способностью и отдельным контуром электропитания/тактов для компонента вне среза. Это позволяет более эффективно управлять электропитанием в таких режимах использования, как при воспроизведении мультимедиа. Срез является настраиваемым компонентом. Например, GT3 поддерживает до двух срезов (каждый срез с 24 исполняющими блоками), GT4 (Halo) может поддерживать до 3 срезов (цифра после букв GT означает количество исполняющих блоков на основе их использования: GT1 поддерживает 12 исполняющих блоков, GT2 — 24, GT3 — 48, а GT4 — 72 исполняющих блока). Архитектура допускает настройку в достаточно широких пределах, чтобы использовать минимальное количество исполняющих блоков в сценариях с низкой нагрузкой, поэтому потребление электроэнергии может составлять от 4 до более чем 65 Вт. Поддержка API графических процессоров 9-го поколения доступна в DirectX* 12, OpenCL™ 2.x, OpenGL* 5.x и Vulkan*.

Рисунок 8.Архитектура графических процессоров 9-го поколения

Подробнее об этих компонентах см. по адресу (ссылка IDF https://software.intel.com/sites/default/files/managed/c5/9a/The-Compute-Architecture-of-Intel-Processor-Graphics-Gen9-v1d0.pdf)

В число усовершенствований и возможностей обработки мультимедиа входят следующие[2]:

• Потребление менее 1 Вт, потребление 1 Вт при проведении видеоконференций.
• Ускорение воспроизведения необработанного видео с камеры (в формате RAW) с помощью новых функций VQE для поддержки воспроизведения видео RAW с разрешением до 4K60 на мобильных платформах.
• Новый режим New Intel® Quick Sync Video с фиксированными функциями (FF).
• Поддержка широкого набора кодеков с фиксированными функциями, ускорение декодирования с помощью ГП.

На рис. 9 показаны кодеки графического процессора поколения 9.

Примечание.Поддержка кодеков мультимедиа и обработки может быть доступна не во всех ОС и приложениях.

Рисунок 9.Поддержка кодеков процессорами Skylake

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

• Смешение, масштабирование, поворот и сжатие изображения.
• Поддержка высокой плотности пикселей (разрешение свыше 4K).
• Поддержка передачи изображения по беспроводному подключению с разрешением вплоть до 4K30.
• Самостоятельное обновление (PSR2).
• CUI X.X — новые возможности, повышенная производительность.

В процессорах Intel® Core™ I7-6700K предусмотрены следующие возможности для геймеров (см. рис. 10). Также поддерживается технология Intel® Turbo Boost 2.0, технология гиперпоточности Intel® и возможность разгона. Прирост производительности по сравнению с ПК пятилетней давности достигает 80 %. Дополнительные сведения см. на этой странице: http://www.intel.com/content/www/us/en/processors/core/core-i7ee-processor.html

1. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i7-6700K и Intel® Core™ i7-875K в тесте SPECint*_rate_base2006 (коэффициент копирования 8).
2. Источник: корпорация Intel. На основе результатов процессоров Intel® Core™ i7-6700K и Intel® Core™ i7-3770K в тесте SPECint*_rate_base2006 (коэффициент копирования 8).
3. Описываемые возможности доступны в отдельных сочетаниях процессоров и наборов микросхем. Предупреждение. Изменение тактовой частоты и/или напряжения может: (i) привести к снижению стабильности системы и снижению срока эксплуатации системы и процессора; (ii) привести к отказу процессора и других компонентов системы; (iii) привести к снижению производительности системы; (iv) привести к дополнительному нагреву или к другим повреждениям; (v) повлиять на целостность данных в системе. Корпорация Intel не тестирует и не гарантирует работу процессоров с техническими параметрами, отличными от установленных.

Рисунок 10.Возможности процессоров Intel® Core™ i7-6700K

Масштабируемость

Микроархитектура Skylake — это настраиваемое ядро: единая конструкция для двух направлений, одно — для клиентских устройств, другое — для серверов без ущерба для требований по мощности и производительности обоих сегментов. На рис. 11 показаны различные модели процессоров и их эффективность с точки зрения мощности для использования в устройствах разного размера и разных типов — от сверхкомпактных Compute Stick до мощных рабочих станций на основе Intel® Xeon®.

Рисунок 11.Доступность процессоров Intel® Core™ для различных типов устройств

Расширенные возможности безопасности

Расширения Intel® Software Guard Extensions (Intel® SGX): Intel SGX — это набор новых инструкций в процессорах Skylake, дающий возможность разработчикам приложений защищать важные данные от несанкционированных изменений и доступа посторонних программ, работающих с более высоким уровнем прав. Это дает приложениям возможность сохранять конфиденциальность и целостность конфиденциальной информации [1], [3]. Skylake поддерживает инструкции и потоки для создания безопасных анклавов, позволяя использовать доверенные области памяти. Дополнительные сведения о расширениях Intel SGX см. на этой странице: https://software.intel.com/en-us/blogs/2013/09/26/protecting-application-secrets-with-intel-sgx

Расширения защиты памяти Intel® (Intel® MPX): Intel MPX — новый набор инструкций для проверки переполнения буфера во время выполнения. Эти инструкции позволяют проверять границы буферов стека и буферов кучи перед доступом к памяти, чтобы процесс, обращающийся к памяти, имел доступ лишь к той области памяти, которая ему назначена. Поддержка Intel MPX реализована в Windows* 10 с помощью встроенных функций Intel MPX в Microsoft Visual Studio* 2015. В большинстве приложений C/C++ можно будет использовать Intel MPX: для этого достаточно заново скомпилировать приложения, не изменяя исходный код и связи с устаревшими библиотеками. При запуске библиотек, поддерживающих Intel MPX, в системах, не поддерживающих Intel MPX (процессоры Intel® Core™ 5-го поколения и более ранних), производительность никак не изменяется: ни повышается, ни снижается. Также можно динамически включать и отключать поддержку Intel MPX [1], [3].

Мы рассмотрели усовершенствования и улучшения архитектуры Skylake. В следующем разделе мы рассмотрим компоненты Windows 10, оптимизированные для использования преимуществ архитектуры Intel® Core™.

Новые возможности Windows 10

Возможности процессоров Intel Core 6-го поколения дополняются возможностями операционной системы Windows 10. Ниже перечислены некоторые основные возможности оборудования Intel и ОС Windows 10, благодаря которым платформы Intel® под управлением Windows 10 работают эффективнее, стабильнее и быстрее[3].

Ϯ Ведется совместная работа Intel и Майкрософт для реализации дальнейшей поддержки в Windows.

Рисунок 12.Возможности Skylake и Windows* 10

Кортана

Голосовой помощник Кортана корпорации Майкрософт доступен в Windows* 10 и дает возможность управлять компьютером с помощью голоса после произнесения ключевой фразы «Привет, Кортана!». Функция пробуждения по голосовой команде использует конвейер обработки звука на ЦП для повышения достоверности распознавания, но можно передать эту функцию на аппаратный цифровой сигнальный процессор звука со встроенной поддержкой Windows 10[3].

Windows Hello*

С помощью биометрического оборудования и Microsoft Passport* служба Windows Hello поддерживает различные механизмы входа в систему с помощью распознавания лица, отпечатков пальцев или радужки глаз. Система без установки каких-либо добавочных компонентов поддерживает все эти возможности входа без использования пароля. Камера переднего обзора Intel® RealSense™ (F200/SR300) поддерживает биометрическую проверку подлинности на основе распознавания лица[3].

Рисунок 13.Windows* Hello с технологией Intel® RealSense™

Фотографии на рис. 13 показывают, как реперные точки, обнаруженные на лице камерой F200, используются для идентификации пользователя и входа в систему. На основе расположения 78 реперных точек на лице создается шаблон лица при первой попытке пользователя войти в систему с помощью распознавания лица. При следующей попытке входа сохраненное расположение реперных точек, полученное камерой, сравнивается с сохраненным шаблоном. Возможности службы Microsoft Passport в сочетании с возможностями камеры позволяют добиться уровня безопасности с показателями ложного допуска в систему в 1 из 100 000 случаев и ложного отказа в допуске в 2–4 % случаев.

Ссылки

1. Intel’s next generation microarchitecture code-named Skylake by Julius Mandelblat: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150818_spcs001/index.html
2. Next-generation Intel® processor graphics architecture, code-named Skylake, by David Blythe: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150818_spcs003/index.html
3. Intel® architecture code-named Skylake and Windows* 10 better together, by Shiv Koushik: http://intelstudios.edgesuite.net/idf/2015/sf/ti/150819_spcs009/index.html
4. Skylake for gamers: http://www.intel.com/content/www/us/en/processors/core/core-i7ee-processor.html
5. Intel’s best processor ever: http://www.intel.com/content/www/us/en/processors/core/core-processor-family.html
6. Skylake Desktop Performance Benchmark: http://www.intel.com/content/www/us/en/benchmarks/desktop/6th-gen-core-i5-6500.html
7. Skylake Laptop Performance Benchmark: http://www.intel.com/content/www/us/en/benchmarks/laptop/6th-gen-core-i5-6200u.html
8. The compute architecture of Intel® processor graphics Gen9: https://software.intel.com/sites/default/files/managed/c5/9a/The-Compute-Architecture-of-Intel-Processor-Graphics-Gen9-v1d0.pdf

Аннотация

После появления камеры Intel® RealSense™ (SR300) и пакета Intel® RealSense™ SDK 2016 R появился новый режим взаимодействия с помощью жестов — режим указателя (Cursor), доступный только при использовании камеры SR300. В этом учебном руководстве описываются изменения кода, необходимые для задействования этой новой функциональности..

Введение

До выпуска пакета Intel RealSense SDK 2016 R1 приложения, в которых нужно управлять движением указателя и обнаруживать действия щелчков, использовали режим Hand, а для определения щелчков применяли распознавание жестов. Эта функциональность режима Hand теперь превратилась в новый режим Cursor. Приложения, использующие прежнюю функциональность, после переделки кода смогут воспользоваться более высокой точностью и более широкими возможностями управления указателем в режиме Cursor.

Обратите внимание, что режим Cursor доступен только для устройств с камерой Intel RealSense SR300. Разработчикам приложений Intel® RealSense™, использующим камеры SR300, необходимо обновить операционную систему до Windows* 10 и использовать Intel RealSense SDK версии 2016 R1.

Учебное руководство

Скорее всего, у вас уже есть приложение, написанное для камеры F200 с помощью Intel RealSense SDK R4 (v6.0). Как двинуться дальше и использовать новый режим Cursor? Это учебное руководство состоит из следующих частей.

Часть 1

Инициализация конвейера процесса должна происходить так же, как в предыдущей версии Intel RealSense SDK. Необходимо создать экземпляр Sense Manager и убедиться, что в процессе нет ошибок.

PXCSenseManager *pSenseMgr = new PXCSenseManager::CreateInstance();
if( !pSenseMgr ) {< continue on to creating the modes >
}

Часть 2

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

PXCHandModule *pHandModule;
PXCHandData *pHandData;
int confidence;
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
	status = pSenseMgr->EnableHand()
	if(status == pxcStatus::PXC_STATUS_NO_ERROR) {
	// Get an instance of PXCHandModule
handModule = pSenseMgr->QueryHand();
// Get an instance of PXCHandConfiguration
PXCHandConfiguration handConfig = handModule
handConfig->EnableGesture("cursor_click");
handConfig->ApplyChanges();
	. . . <дополнительные параметры конфигурации> . . .
}
}

Часть 3

В Intel RealSense SDK начиная с версии 2016 R1 реализован новый режим Cursor, действия с указателем отделены от режима Hand. Это означает, что необходимо переработать прежний код, запрашивавший режим Hand в Sense Manager. Новый код будет выглядеть так:

PXCHandCursorModule *pCursorModule;
PXCCursorData::BodySideType bodySide;
// обратите внимание, что значений Confidence больше нет
. . . <дополнительная библиотека и настройка переменных> . . .
pxcStatus status;
if( !pSenseMgr ) {
// Enable handcursor tracking
status = pSenseMgr::EnableHandCursor();
	if(status == pxcStatus.PXC_STATUS_NO_ERROR) {
	// Get an instance of PXCCursorModule
pCursorModule = pSenseMgr->QueryHandCursor();
// Get an instance of the cursor configuration
PXCCursorConfiguration *pCursorConfig = CursorModule::CreateActiveConfiguration();

// Make configuration changes and apply them
pCursorConfig.EnableEngagement(true);
pCursorConfig.EnableAllGestures();
pCursorConfig.ApplyChanges();
	. . . <дополнительные параметры конфигурации> . . .

}
}

Часть 4

Реализация примеров основных вычислительных циклов для синхронных и асинхронных функций см. в документации Intel RealSense™ SDK 2016 R1в разделе Реализация основного вычислительного цикла «Модуль Cursor [SR300]».

Асинхронный (рекомендуемый) подход будет выглядеть так:

class MyHandler: public PXCSenseManager::Handler {
public:
    virtual pxcStatus PXCAPI OnModuleProcessedFrame(pxcUID mid, PXCBase *module, PXCCapture::Sample *sample) {
       // check if the callback is from the hand cursor tracking module
       if (mid==PXCHandCursorModule::CUID) {
           PXCHandCursorModule *cursorModule=module->QueryInstance<PXCHandCursorModule>();
               PXCCursorData *cursorData = cursorModule->CreateOutput();
           // process cursor tracking data
       }

       // return NO_ERROR to continue, or any error to abort
       return PXC_STATUS_NO_ERROR;
    }
};
. . . <объявление SenseManager> . . .
// Initialize and stream data
MyHandler handler; // Instantiate the handler object

// Register the handler object
pSenseMgr->Init(&handler);

// Initiate SenseManager’s processing loop in blocking mode
// (function exits only when processing ends)
pSenseMgr ->StreamFrames(true);

// Release SenseManager resources
pSenseMgr ->Release()

Заключение

В Intel RealSense SDK 2016 R1 изменилась реализация и доступ к указателю руки, но все изменения однородны, что упрощает переделку кода. В приведенном выше примере кода демонстрируется эта простота: показано, что структура программы при инициализации, настройке и покадровом выполнении может остаться неизменной, при этом программа будет использовать расширенные возможности нового режима Cursor.

Напомним, что новый режим Cursor доступен только для систем с камерой SR300 (камера может быть встроенной или подключаться в виде отдельного периферийного устройства) и с версией RealSense™ SDK 2016 R1. Возможность кода обнаруживать модель камеры и поддерживать одновременно камеры F200 и SR300 будет описана в других учебных руководствах.

Аннотация

В этой статье описывается создание кода для приложения с виртуальным джойстиком (см. рис. 1), использующего новый модуль Hand Cursor в составе Intel® RealSense™ SDK. Проект разрабатывается на C#/XAML, его можно собрать с помощью Microsoft Visual Studio* 2015.

Рисунок 1. Приложение RS Joystick, управляющее имитацией полета в Google Earth*

Введение

В Intel RealSense SDK R5появилась поддержка новой модели камеры Intel® RealSense™ SR300. Камера SR300 — развитие модели на F200, в ней усовершенствован ряд возможностей и добавлен новый режим работы Hand Cursor.

Согласно описанию в документации SDKмодуль Hand Cursor возвращает одну точку для положения руки, что позволяет добиться высокой точности и скорости отслеживания. Цель этого модуля — упростить работу с элементами управления пользовательского интерфейса с помощью руки при поддержке ограниченного набора жестов.

RS Joystick — программный эмулятор джойстика, описанный в этой статье. Это приложение сопоставляет трехмерные данные руки, предоставляемые пакетом SDK, в виртуальные элементы управления джойстиком, что дает возможность взаимодействия с приложениями, управляемыми при помощи джойстика.

Приложение RS Joystick использует следующие компоненты модуля Hand Cursor.

• Тип Body Side:приложение оповещает пользователя о том, какая из рук управляет виртуальным джойстиком (на основе порядка от ближнего к дальнему).
• Жест Cursor-Click:пользователь может переключать состояние ВКЛЮЧЕНО/ВЫКЛЮЧЕНО кнопки 1 на виртуальном джойстике с помощью жеста щелчка пальцами.
• Адаптивное отслеживание точки:приложение отображает нормализованную трехмерную точку внутри воображаемой «ограничительной рамки», заданной модулем Hand Cursor, и использует эти данные для управления виртуальным джойстиком по осям X, Y и Z.
• Данные оповещений:приложение использует оповещения Cursor Not Detected, Cursor Disengagedи Cursor Out Of Borderдля изменения цвета джойстика с зеленого на красный, когда рука пользователя находится вне дальности действия камеры SR300.

(Дополнительные сведения о модуле Hand Cursor см. в статье “Что можно делать в режиме Intel RealSense Cursor?”)

Предварительные требования

Требуются некоторые знания C# и понимание базовых действий в Visual Studio, таких как сборка исполняемого файла. Также пригодится опыт добавления сторонних библиотек в индивидуальные программные проекты. Впрочем, даже если раньше вы этого не делали, трудностей возникнуть не должно, поскольку в этом руководстве приводятся подробные инструкции необходимых действий. В системе должна быть камера переднего обзора SR300, последние версии SDK и Intel® RealSense™ Depth Camera Manager (DCM). Кроме того, система должна отвечать требованиям к оборудованию, перечисленным здесь. И наконец, компьютер должен работать под управлением Microsoft Windows* 10 Threshold 2.

Стороннее программное обеспечение

В этом проекте, помимо пакета Intel RealSense SDK, используется сторонний драйвер виртуального джойстика под названием vJoy* и несколько библиотек динамической компоновки (DLL). Эти программные компоненты не входят в распространяемый код, связанный с этим проектом, поэтому сведения по загрузке и установке драйвера устройства приводятся ниже.

Установите Intel RealSense SDK

Загрузите и установите DCM и SDK по адресу https://software.intel.com/en-us/intel-realsense-sdk/download. На момент написания этой статьи последними версиями компонентов были следующие:

• Intel RealSense Depth Camera Manager (SR300) v3.1.25.1077
• Intel RealSense SDK v8.0.24.6528

Установите драйвер устройства vJoy и SDK

Загрузите и установите драйвер устройства vJoy: http://vjoystick.sourceforge.net/site/index.php/download-a-install/72-download. При получении соответствующей инструкции перезагрузите компьютер, чтобы завершить установку.

После установки драйвер устройства vJoy появится в разделе «Устройства HID» в диспетчере устройств (см. рис. 2).

Рисунок 2.Диспетчер устройств

Откройте в Windows 10 меню «Пуск» и выберите Все приложения. Вы увидите несколько установленных компонентов vJoy, как показано на рис. 3.

Рисунок 3.Меню «Пуск» в Windows

Чтобы открыть браузер по умолчанию и перейти на страницу загрузки, нажмите кнопку vJoy SDK.

После загрузки скопируйте ZIP-файл во временную папку и найдите DLL-библиотеки C# в папке \SDK\c#\x86.

Мы добавим эти DLL-библиотеки в проект Visual Studio после его создания (см. описание ниже).

Создайте новый проект Visual Studio

• Запустите Visual Studio 2015.
• В меню выберите Файл, Создать, Проект….
• На экране «Создание проекта» разверните «Шаблоны» и выберите Visual C#, Windows.
• Выберите Приложение WPF.
• • Укажите расположение проекта и его имя. Для этого проекта мы используем расположение C:\, а имя приложения — RsJoystick.

На рис. 4 показаны настройки этого проекта.

Рисунок 4.Настройки нового проекта в Visual Studio*

Нажмите кнопку ОК, чтобы создать проект.

Скопируйте библиотеки в проект

Для создания приложений Intel® RealSense™ на языке C# требуются две библиотеки.

• libpxcclr.cs.dll – управляемая DLL-библиотека интерфейса C#.
• libpxccpp2c.dll – неуправляемая DLL-библиотека C++ P/Invoke.

Еще две библиотеки дадут возможность приложению обмениваться данными с драйвером устройства vJoy.

• vJoyInterface.dll – библиотека API на языке C.
• vJoyInterfaceWrap.dll – оболочка C# для библиотеки API на языке C.

Чтобы упростить структуру проекта, мы скопируем все четыре библиотеки в папку проекта.

• Щелкните проект RsJoystick правой кнопкой мыши и выберите Добавить, Существующий элемент…
• Перейдите в папку библиотек vJoy (\SDK\c#\x86) и выберите vJoyInterface.dll и vJoyInterfaceWrap.dll. Примечание. В поле типа файлов может потребоваться выбрать Все файлы (*.*), чтобы DLL-библиотеки стали видны.
• Нажмите кнопку Добавить.

Аналогичным образом скопируйте в проект DLL-библиотеки Intel RealSense SDK.

• Щелкните проект RsJoystick правой кнопкой мыши, выберите Добавить, Существующий элемент…
• Перейдите в папку библиотек x86, это папка C:\Program Files (x86)\Intel\RSSDK\bin\win32, если пакет SDK был установлен в папку по умолчанию.
• Выберите libpxcclr.cs.dll и libpxccpp2c.dll.
• Нажмите кнопку Добавить.

Теперь все четыре файла должны быть видны в обозревателе решений в проекте RsJoystick.

Создайте ссылки на библиотеки

Если необходимая библиотека физически скопирована в проект Visual Studio, необходимо создать ссылки на управляемыебиблиотеки (.NET), чтобы приложение могло их использовать. Щелкните правой кнопкой мыши «Ссылки» (под проектом RsJoystick) и выберите Добавить ссылку…В окне диспетчера ссылок нажмите кнопку Обзори перейдите в папку проекта (c:\RsJoystick\RsJoystick). Выберите файлы libpxcclr.cs.dll и vJoyInterfaceWrap.dll, затем нажмите кнопку Добавить. Нажмите кнопку OKв диспетчере ссылок.

Для правильной работы управляемых DLL-библиотек оболочки необходимо скопировать неуправляемые DLL-библиотеки в выходную папку проекта перед запуском приложения. В обозревателе решений щелкните файл libpxccpp2c.dll, чтобы выбрать его. В окне свойств будут показаны свойства файла libpxccpp2c.dll. Найдите поле Копировать в выходной каталоги выберите в раскрывающемся списке Всегда копировать. Повторите этот шаг для файла vJoyInterface.dll. За счет этого неуправляемые DLL-библиотеки будут скопированы в выходную папку проекта при сборке приложения.

Здесь может появиться предупреждение о несовпадении между архитектурой процессора, заданной для собираемого проекта, и архитектурой процессора библиотек. Уберите это предупреждение, выполнив следующие действия:

• Найдите ссылку на диспетчер конфигураций в раскрывающемся списке в меню (см. рис. 5).
• Выберите Диспетчер конфигураций.
• В окне диспетчера конфигураций разверните раскрывающийся список в столбце Платформаи выберите Новая.
• Выберите x86в качестве новой платформы и нажмите кнопку OK.
• Закройте окно диспетчера конфигураций.

Рисунок 5. Диспетчер конфигураций

На этом этапе проект должен быть собран и запущен без каких-либо ошибок или предупреждений. Кроме того, если изучить содержимое выходной папки (c:\RsJoystick\RsJoystick\bin\x86\Debug), вы увидите, что в нее скопированы все четыре библиотеки.

Пользовательский интерфейс

В пользовательском интерфейсе (см. рис. 6.) отображаются следующие сведения:

• Рука пользователя, управляющая виртуальным джойстиком (на основе порядка доступа от ближнего к дальнему; ближайшая к камере рука считается управляющей).
• Состояние ВКЛЮЧЕНО/ВЫКЛЮЧЕНО кнопки 1 на виртуальном джойстике (управляется с помощью жеста щелчка пальцами).
• Эллипс, в котором отслеживается относительное положение руки пользователя по осям X и Y; диаметр изменяется на основе оси Z в соответствии с расстоянием между рукой и камерой.
• Данные Adaptive Point по осям X, Y и Z из SDK представлены в виде нормализованных значений, диапазон — от 0 до 1.
• Цветная рамка, цвет которой меняется с зеленого на красный, когда рука пользователя выходит за пределы дальности действия камеры SR300.
• С помощью ползунка регулируется чувствительность для каждой оси.

Рисунок 6. Пользовательский интерфейс

Полный исходный код XAML представлен в таблице 1. Его можно скопировать и вставить непосредственно в код MainWindow.xaml, автоматически сформированный при создании проекта.

Таблица 1.Исходный код XAML: MainWindow.xaml

<Window x:Class="RsJoystick.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:RsJoystick"
        mc:Ignorable="d"
        Title="RSJoystick" Height="420" Width="420" Background="#FF222222" Closing="Window_Closing"><Window.Resources><Style x:Key="TextStyle" TargetType="TextBlock"><Setter Property="Foreground" Value="White"/><Setter Property="FontSize" Value="14"/><Setter Property="Text" Value="-"/><Setter Property="Margin" Value="4"/><Setter Property="HorizontalAlignment" Value="Center"/></Style></Window.Resources><StackPanel VerticalAlignment="Center" HorizontalAlignment="Center" Width="320"><TextBlock x:Name="uiBodySide" Style="{StaticResource TextStyle}"/><TextBlock x:Name="uiButtonState" Style="{StaticResource TextStyle}"/><Border x:Name="uiBorder" BorderThickness="2" Width="200" Height="200" BorderBrush="Red" Margin="4"><Canvas x:Name="uiCanvas" ClipToBounds="True"><Ellipse x:Name="uiCursor" Height="10" Width="10" Fill="Yellow"/><Ellipse Height="50" Width="50" Stroke="Gray" Canvas.Top="75" Canvas.Left="75"/><Rectangle Height="1" Width="196" Stroke="Gray" Canvas.Top="100"/><Rectangle Height="196" Width="1" Stroke="Gray" Canvas.Left="100"/></Canvas></Border><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiX" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderX" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiY" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderY" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel><StackPanel Orientation="Horizontal" HorizontalAlignment="Center"><TextBlock x:Name="uiZ" Style="{StaticResource TextStyle}" Width="80"/><Slider x:Name="uiSliderZ" Width="150" ValueChanged="sldSensitivity_ValueChanged" Margin="4"/></StackPanel></StackPanel></Window>

Исходный код программы

Полный исходный код приложения RSJoystick на языке C# представлен в таблице 2. Его можно скопировать и вставить непосредственно в код MainWindow.xaml.cs, автоматически сформированный при создании проекта.

Таблица 2.Исходный код C#: MainWindow.xaml.cs

//--------------------------------------------------------------------------------------
// © Intel Corporation, 2016.
// Все права защищены.
//
// Предоставляется разрешение на использование, создание, распространение и подготовку производных работ
// этого программного обеспечения для любых целей без уплаты отчислений при условии, что приведенное выше уведомление об авторских правах
// и данное уведомление сохранятся во всех копиях. Корпорация Intel не делает никаких заявлений относительно
// пригодности этого программного обеспечения для любых целей. ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ».
// КОРПОРАЦИЯ INTEL НЕ ПРЕДОСТАВЛЯЕТ НИКАКИХ ГАРАНТИЙ, ЯВНЫХ И ПОДРАЗУМЕВАЕМЫХ,
// ВКЛЮЧАЯ ГАРАНТИЮ ОТСУТСТВИЯ ОПОСРЕДОВАННЫХ ИЛИ ИНЫХ НЕПРЯМЫХ УБЫТКОВ В СВЯЗИ С ИСПОЛЬЗОВАНИЕМ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ,
// ВКЛЮЧАЯ ГАРАНТИЮ НЕНАРУШЕНИЯ КАКИХ-ЛИБО ПРАВ СОБСТВЕННОСТИ И ВКЛЮЧАЯ
// ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ ИЛИ ПРИГОДНОСТИ ДЛЯ КАКОЙ-ЛИБО ЦЕЛИ. Корпорация Intel не
// несет ответственности за любые ошибки, которые могут быть в этом программном обеспечении, и не принимает
// никаких обязательств относительно обновления этого программного обеспечения.
//--------------------------------------------------------------------------------------
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using vJoyInterfaceWrap;
using System.Threading;
using System.Windows.Shapes;

namespace RsJoystick
{
    /// <сводка>
    /// Логика взаимодействия для MainWindow.xaml
    /// </сводка>
    public partial class MainWindow : Window
    {
        private PXCMSenseManager sm;
        private PXCMHandCursorModule cursorModule;
        private PXCMCursorConfiguration cursorConfig;
        private vJoy joystick;
        private Thread update;
        private double joySensitivityX;
        private double joySensitivityY;
        private double joySensitivityZ;
        private const uint joyID = 1;
        private const uint MaxSensitivity = 16384;

        public MainWindow()
        {
            InitializeComponent();

            // Configure the sensitivity controls
            uiSliderX.Maximum = MaxSensitivity;
            uiSliderY.Maximum = MaxSensitivity;
            uiSliderZ.Maximum = MaxSensitivity;
            joySensitivityX = uiSliderX.Value = MaxSensitivity / 2;
            joySensitivityY = uiSliderY.Value = MaxSensitivity / 2;
            joySensitivityZ = uiSliderZ.Value = MaxSensitivity / 2;

            // Создание экземпляра джойстика
            joystick = new vJoy();
            joystick.AcquireVJD(joyID);

            // Configure the cursor mode module
            ConfigureRealSense();

            // Запуск потока Update
            update = new Thread(new ThreadStart(Update));
            update.Start();
        }

        public void ConfigureRealSense()
        {
            // Создание экземпляра SenseManager
            sm = PXCMSenseManager.CreateInstance();

            // Включение отслеживания указателя
            sm.EnableHandCursor();

            // Получение экземпляра модуля Hand Cursor
            cursorModule = sm.QueryHandCursor();

            // Получение экземпляра конфигурации указателя
            cursorConfig = cursorModule.CreateActiveConfiguration();

            // Создание и применение изменений конфигурации
            cursorConfig.EnableEngagement(true);
            cursorConfig.EnableAllGestures();
            cursorConfig.EnableAllAlerts();
            cursorConfig.ApplyChanges();

            // Инициализация конвейера SenseManager
            sm.Init();
        }

        private void Update()
        {
            bool handInRange = false;
            bool joyButton = false;

            // Запуск цикла AcquireFrame-ReleaseFrame
            while (sm.AcquireFrame(true).IsSuccessful())
            {
                PXCMCursorData cursorData = cursorModule.CreateOutput();
                PXCMPoint3DF32 adaptivePoints = new PXCMPoint3DF32();
                PXCMCursorData.BodySideType bodySide;

                // Получение текущих данных указателя
                cursorData.Update();

                // Проверка наличия данных оповещений
                for (int i = 0; i < cursorData.QueryFiredAlertsNumber(); i++)
                {
                    PXCMCursorData.AlertData alertData;
                    cursorData.QueryFiredAlertData(i, out alertData);

                    if ((alertData.label == PXCMCursorData.AlertType.CURSOR_NOT_DETECTED) ||
                        (alertData.label == PXCMCursorData.AlertType.CURSOR_DISENGAGED) ||
                        (alertData.label == PXCMCursorData.AlertType.CURSOR_OUT_OF_BORDERS))
                    {
                        handInRange = false;
                    }
                    else
                    {
                        handInRange = true;
                    }
                }

                // Проверка срабатывания жеста щелчка
                PXCMCursorData.GestureData gestureData;

                if (cursorData.IsGestureFired(PXCMCursorData.GestureType.CURSOR_CLICK, out gestureData))
                {
                    joyButton = !joyButton;
                }

                // Отслеживание указателя: находится ли он в пределах допустимой дальности
                int detectedHands = cursorData.QueryNumberOfCursors();

                if (detectedHands > 0)
                {
                    // Получение данных указателя с помощью индекса на основе порядка
                    PXCMCursorData.ICursor iCursor;
                    cursorData.QueryCursorData(PXCMCursorData.AccessOrderType.ACCESS_ORDER_NEAR_TO_FAR,
                                               0,
                                               out iCursor);

                    adaptivePoints = iCursor.QueryAdaptivePoint();

                    // Получение управляющей стороны тела (т. е. правая или левая рука)
                    bodySide = iCursor.QueryBodySide();

                    // Управление виртуальным джойстиком
                    ControlJoystick(adaptivePoints, joyButton);
                }
                else
                {
                    bodySide = PXCMCursorData.BodySideType.BODY_SIDE_UNKNOWN;
                }

                // Обновление пользовательского интерфейса
                Render(adaptivePoints, bodySide, handInRange, joyButton);

                // Возобновление обработки следующего кадра
                cursorData.Dispose();
                sm.ReleaseFrame();
            }
        }

        private void ControlJoystick(PXCMPoint3DF32 points, bool buttonState)
        {
            double joyMin;
            double joyMax;

            // Масштабирование данных по оси X
            joyMin = MaxSensitivity - joySensitivityX;
            joyMax = MaxSensitivity + joySensitivityX;
            int xScaled = Convert.ToInt32((joyMax - joyMin) * points.x + joyMin);

            // Масштабирование данных по оси Y
            joyMin = MaxSensitivity - joySensitivityY;
            joyMax = MaxSensitivity + joySensitivityY;
            int yScaled = Convert.ToInt32((joyMax - joyMin) * points.y + joyMin);

            // Масштабирование данных по оси Z
            joyMin = MaxSensitivity - joySensitivityZ;
            joyMax = MaxSensitivity + joySensitivityZ;
            int zScaled = Convert.ToInt32((joyMax - joyMin) * points.z + joyMin);

            // Обновление настроек джойстика
            joystick.SetAxis(xScaled, joyID, HID_USAGES.HID_USAGE_X);
            joystick.SetAxis(yScaled, joyID, HID_USAGES.HID_USAGE_Y);
            joystick.SetAxis(zScaled, joyID, HID_USAGES.HID_USAGE_Z);
            joystick.SetBtn(buttonState, joyID, 1);
        }

        private void Render(PXCMPoint3DF32 points,
                            PXCMCursorData.BodySideType bodySide,
                            bool handInRange,
                            bool buttonState)
        {
            Dispatcher.Invoke(delegate
            {
                // Изменение отображения границы, чтобы указать, находится ли рука в пределах допустимой дальности
                uiBorder.BorderBrush = (handInRange) ? Brushes.Green : Brushes.Red;

                // Масштабирование данных указателя для отображения
                double xScaled = uiCanvas.ActualWidth * points.x;
                double yScaled = uiCanvas.ActualHeight * points.y;
                uiCursor.Height = uiCursor.Width = points.z * 100;

                // Перемещение указателя по экрану
                Canvas.SetRight(uiCursor, (xScaled - uiCursor.Width / 2));
                Canvas.SetTop(uiCursor, (yScaled - uiCursor.Height / 2));

                // Обновление отображаемых значений данных
                uiX.Text = string.Format("X Axis: {0:0.###}", points.x);
                uiY.Text = string.Format("Y Axis: {0:0.###}", points.y);
                uiZ.Text = string.Format("Z Axis: {0:0.###}", points.z);
                uiBodySide.Text = string.Format("Controlling Hand: {0}", bodySide);
                uiButtonState.Text = string.Format("Button State (use 'Click' gesture to toggle): {0}",
                                                    buttonState);
            });
        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            update.Abort();
            cursorConfig.Dispose();
            cursorModule.Dispose();
            sm.Dispose();
            joystick.ResetVJD(joyID);
            joystick.RelinquishVJD(joyID);
        }

        private void sldSensitivity_ValueChanged(object sender,
                                                 RoutedPropertyChangedEventArgs<double> e)
        {
            var sliderControl = sender as Slider;

            switch (sliderControl.Name)
            {
                case "uiSliderX":
                    joySensitivityX = sliderControl.Value;
                    break;
                case "uiSliderY":
                    joySensitivityY = sliderControl.Value;
                    break;
                case "uiSliderZ":
                    joySensitivityZ = sliderControl.Value;
                    break;
            }
        }
    }
}

Сведения о коде

Чтобы код был как можно проще, все методы заключены в один класс. Как показано в исходном коде в таблице 2, класс MainWindow состоит из следующих методов:

• MainWindow(): несколько частных классов и членов-переменных объявляются в начале класса MainWindow. В конструкторе MainWindow создаются экземпляры этих объектов и происходит инициализация переменных.
• ConfigureRealSense():этот метод обрабатывает создание объекта SenseManager и работу модуля Hand Cursor, а также настраивает модуль Cursor.
• Update(): согласно описанию в Справочном руководстве Intel RealSense SDKинтерфейс SenseManager может быть использован либо вызовами процедур, либо обратными вызовами событий. В приложении RSJoystick мы используем вызовы процедур в качестве методики взаимодействия. Они получают и высвобождают запуски циклов кадров в потоке Update() независимо от основного потока пользовательского интерфейса. Этот поток работает непрерывно; в нем мы получаем данные указателя, жестов и оповещений.
• ControlJoystick(): этот метод вызывается из метода Update() при обнаружении руки пользователя. Этому методу передаются данные Adaptive Point вместе с состоянием кнопки виртуального джойстика (оно переключается жестом CURSOR_CLICK). Данные Adaptive Point масштабируются на основе значений, полученных от ползунков регулировки чувствительности. С помощью ползунка и расчета масштабирования пользователь может выбирать масштаб значений, передаваемых в метод vJoy SetAxis(). Этот метод ожидает значения в диапазоне от 0 до 32 768. Если ползунок регулировки чувствительности установлен в максимальное положение, то соответствующие данные указателя будут преобразованы в значение в диапазоне от 0 до 32 768. При снижении чувствительности этот диапазон будет сужен для такой же траектории руки. Например: от 8192 до 24 576.
• Render(): этот метод вызывается из потока Update() и использует метод Dispatcher.Invoke() для выполнения операций с потоком пользовательского интерфейса. Это касается обновления положения эллипса на полотне и обновления значений данных в элементах управления TextBlock.
• sldSensitivity_ValueChanged(): этот обработчик событий срабатывает при регулировке положения ползунков.

Использование приложения

Можно проверить работу приложения, запустив vJoy Monitor в меню «Пуск» в Windows 10 (см. рис. 3). Как показано на рис. 7, можно отслеживать эффекты перемещения руки вдоль трех осей и выполнения жеста щелчка для переключения виртуальной кнопки 1.

Рисунок 7. Тестирование приложения с vJoy Monitor

Чтобы попробовать приложение в более интересном контексте, можно запустить симулятор полета в программе Google Планета Земля* (см. рис. 1). Согласно описанию на сайте, «Google Планета Земля — это виртуальные путешествия по всем уголкам Земли, спутниковые изображения, карты местности, трехмерные здания и самые разные объекты — от галактик в космосе до океанских впадин». (https://www.google.com/earth).

После загрузки и установки программы Google Планета Земля ознакомьтесь с инструкциями, приведенными здесь, для запуска симулятора полета. Сначала следует снизить чувствительность для осей X и Y в RSJoystick, чтобы движения руки не слишком сильно влияли на перемещение виртуального самолета. Для оси Z необходимо установить ползунок в максимальное положение. Немного привыкнув, вы сможете управлять виртуальным самолетом при помощи плавных движений руки.

Заключение

В этой статье приведено простое пошаговое руководство, в котором описывается создание приложения-эмулятора джойстика с помощью Intel RealSense SDK и использование модуля Hand Cursor, который поддерживается камерой SR300.

О технологии Intel RealSense

Дополнительные сведения о пакете Intel RealSense SDK для Windows см. по адресу https://software.intel.com/en-us/intel-realsense-sdk.

Об авторе

Брайан Браун (Bryan Brown) — инженер по разработке программных приложений в подразделении Software and Services Group корпорации Intel.  

Download PDF 1.38 MB

Введение

Unreal Game Engine 3 (UE3) компании Epic Games (https://epicgames.com/) — популярный модуль или «движок» для создания игр для ПК. Технология Intel® RealSense™используется для распознавания лиц и движения рук, чтобы расширить игровые возможности. В среде UE3 единственной рекомендацией является использование сценария Unreal в пакете Unreal Development Kit (UDK); настраиваемые функции следует добавлять в UDK в качестве подключаемого модуля, но в составе Intel® RealSense™ SDKнет подключаемого модуля для UDK.

В этой статье описывается добавление возможностей Intel RealSense SDK в средства управления игровыми персонажами в играх жанра MMORPG (массовые многопользовательские сетевые ролевые игры) в UE3 с помощью C++, а не сценариев Unreal. Определение и изменение структуры лица персонажа называется «монтажом лиц». Существует несколько способов монтажа лиц в игре, но мы рассмотрим применение Intel RealSense SDK в качестве способа изменения структуры лицевых костей игровых персонажей, в том числе вопросы производительности и нагрузки.

В этой статье содержится следующее.

• Описание способа монтажа лиц.
• Использование Autodesk 3ds Max* вместе с Unreal Engine.
• Описание систем координат в Unreal: X-Y-Z, эйлеровы углы (поворот вокруг продольной, поперечной и вертикальной осей) и кватернионы.
• Включение Intel RealSense SDK в Unreal Engine.
• Соединение алгоритма Intel RealSense SDK с игровым движком.

Монтаж лиц в игре

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

• Анимация с использованием сценариев. Заранее просчитанная анимация широко распространена в играх, но ее сложно применить для монтажа лиц в реальном времени. Впрочем, если нужно, чтобы выражение лица изменилось в соответствии с какой-либо простой эмоцией, это наилучший и самый простой способ. Для управления анимацией используется сценарий Unreal или Matinee.
• Коммерческая программа для монтажа лиц — FaceFX*. FaceFX — коммерческий инструмент для монтажа лиц компании OC3 Entertainment (https://www.facefx.com), поддерживающий Unreal. Этот инструмент предварительно лицензирован в Unreal Engine 3. В FaceFX поддерживается монтаж всего тела и изменение лиц персонажей.
• Целевая трансформация. В предыдущем образце кода Intel RealSense SDK с монтажом лиц в Unity (Angie) использовалась трансформация Morph. Это простой способ применения Intel RealSense SDK в игре, но при этом необходимо создавать цель трансформации для каждого персонажа. В MMORPG-играх обычно бывает от трех до шести рас или племен, при этом игрок может изменять и лицо, и тело своего персонажа, поэтому суммарное количество возможных сочетаний измеряется тысячами. При этом потребуется несколько тысяч Morph-ресурсов лица, а производительность ниже по сравнению с управлением костями.
• Управление костями. Если Intel RealSense SDK может определять координаты костей, этот метод вполне применим в играх. Даже при наличии нескольких тысяч возможных сочетаний персонажей существует сравнительно немного лицевых структур (количество рас, умноженное на два пола). Кроме того, этот метод не повлияет на отображение и на производительность игры.

Например, в MMORPG-игре Bless* (http://bless-source.com/, http://bless.pmang.com/) существует 10 племен, но только 8 типов лицевых костей: у эльфов (двух полов), волков (двух полов), людей (двух полов) и расы «маску» (двух полов). Полный список наименований костей см. в разделе «Структура костей лица» в конце этого документа.

Рисунок 1. Игровые персонажи в MMORPG-игре

Среда

• Компьютер для тестирования: процессор Intel® Core™ i7-5775C, 16 ГБ ОЗУ DDR, твердотельный накопитель (SSD) объемом 256 ГБ. Рекомендуемая конфигурация: мощный ЦП, например Intel® Core™ i7 6-го поколения (Skylake), мощный внешний графический адаптер и твердотельный накопитель с достаточным объемом пустого пространства (не менее 50 ГБ). Рекомендуется использовать твердотельные накопители вместо жестких дисков для повышения скорости ввода-вывода. Камера Intel® RealSense™ (F200) или обычная веб-камера.
• Microsoft Windows* 7, 64-разрядная версия
• Autodesk 3ds Max 2014
• Исходный код Epic Games Unreal Engine 3 source code (требуется лицензия)
• Microsoft Visual Studio* 2010
• Intel RealSense SDK 6.0.21.6598 и Intel® RealSense™ Depth Camera Manager 1.4.27.41944

Установка

1. Установите 64-разрядную версию Windows 7 на компьютер, обновите драйверы для всех устройств.
2. Скопируйте исходный код UE3 на локальный диск.
3. Установите и обновите Microsoft Visual Studio 2010. Если требуется отладка в Visual Studio 2010, необходимо включить сценарий отладки. См. автоматическое расширение установки отладчика.
4. (Необязательно) Установите Autodesk 3ds Max 2014, если нужно экспортировать FBX-файл из MAX-файла.

Экспорт MAX-файла в формат FBX для импорта в UE3

В большинстве распространенных программ трехмерного моделирования, таких как Autodesk 3ds Max или Maya*, поддерживается экспорт трехмерных моделей в Unreal Engine или Unity* посредством файлов в формате FBX.

Описанные действия предназначены для Autodesk 3ds Max 2014.

1. Откройте MAX-файл со структурой костей. Показано расположение костей и внешний вид.

   
   Рисунок 2.Откройте MAX-файл

2. Экспортируйте этот файл в формат FBX. Если появится предупреждение о том, что режим by-layer не поддерживается, включите режим by-object для правильного экспорта.

   
   Рисунок 3.Экспорт в формат FBX

3. Выберите все объекты, щелкните правой кнопкой мыши и выберите Object Properties.

   
   Рисунок 4.Параметры экспорта

4. Нажмите кнопку By Object для переключения режима by-layer.

   
   Рисунок 5.Параметры экспорта: режим by-layer

5. Выберите Menu, затем выберите Export. Введите имя экспортируемого файла в поле FBX. Можно выбрать animation и bake animation для проверки анимации в UE3.

   
   Рисунок 6.Экспорт с анимацией

Импортируйте FBX-файл в UE3 Editor
Если вы используете автономную версию UE3 в стандартной конфигурации (DirectX* 9, 32-разрядная версия), можно использовать редактор Unreal Editor.

1. Запустите UE3 Editor с помощью следующих команд.

   Выполните команду CMD и перейдите в папку UE3 (в моем случае это папка C:\UE3).
   Перейдите в папку \Binaries\Win32\.
   Выполните команду examplegame.exe editor -NoGADWarning.

   
   Рисунок 7. Запуск Unreal Editor

2. В окне Content Browser щелкните Importи выберите FBX file. Нажмите кнопку OKдля импорта. После импорта можно просмотреть объекты Animset, SkeletonMesh и прочие.

   
   Рисунок 8.Unreal Editor: окно Content Browser

3. Чтобы проверить импортированный FBX-файл, щелкните правой кнопкой мыши Animsetи выберите Edit Using AnimSet Viewer.

   
   Рисунок 9.Unreal editor - AnimSet Viewer

4. Можно отрегулировать размер и положение лица с помощью кнопок мыши (левая кнопка — поворот, средняя кнопка — положение, правая кнопка — масштаб). Слева отображаются наименования костей, справа — скелеты. При воспроизведении анимации также будет показано время кадра и разница положения и поворота.

   
   Рисунок 10.AnimSet Viewer.

   
   Рисунок 11.AnimSet Viewer: регулировка масштаба

5. Выберите нужную кость (на этих рисунках выбрана кость BN_Ear_R 53) и систему координат X-Y-Z. Для перемещения перетащите вдоль осей X, Y или Z.

   
   Рисунок 12.AnimSet Viewer: проверка кости

6. Для проверки в системе координат с эйлеровыми углами (поворот вокруг поперечной, продольной и вертикальной осей) нажмите пробел. При смене системы координат у правого уха будет показана эйлерова система координат. Для регулировки поворота перетаскивайте окружности P-Y-R.

   
   Рисунок 13.Смена системы координат

Создание карт и уровней в UE3 Editor

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

1. Запустите UE3 Editor с помощью следующих команд.
   
   Выполните команду CMD и перейдите в папку UE3 (в моем случае это папка C:\UE3).
   Перейдите в папку \Binaries\Win32\.
   Выполните команду examplegame.exe editor -NoGADWarning.

2. Используйте один из уровней шаблона или самостоятельно создайте простой уровень. Нажмите кнопку BSP Cubeправой кнопкой мыши. Во всплывающем окне введите 1024 в качестве значения для параметров X, Y, Z и установите флажок Hollow?. Затем на панели инструментов слева щелкните Add.

   
   Рисунок 14. Unreal Editor: создание слоя

3. Для передвижения куба используйте клавиши WASD или клавиши со стрелками и мышь. Также можно использовать перетаскивание, удерживая нажатыми левую, среднюю или правую кнопки мыши для перемещения камеры.

   
   Рисунок 15. Unreal Editor: начальное расположение

4. Чтобы добавить начальное расположение в игру, щелкните пол правой кнопкой мыши, выберите Add Actor, затем выберите Add Playerstart.

5. Чтобы добавить источник света, щелкните стену правой кнопкой мыши, выберите Add Actor, затем выберите Add Light(Point).

   
   Рисунок 16. Unreal Editor: добавление света

6. Чтобы добавить лицевую кость актера, нажмите клавишу Tabдля перемещения обозревателя содержимого и перетащите трехмерную модель скелета в UE Editor.

   
   Рисунок 17. Unreal Editor: добавление актера

7. Для регулировки размера введите коэффициент масштабирования в правом нижнем углу.

8. Для регулировки положения выберите значок Translation modeв левом верхнем углу. Для перемещения персонажа используйте координаты X-Y-Z.

9. Для регулировки поворота выберите значок Rotation modeв левом верхнем углу. Для перемещения персонажа используйте координаты P-Y-R.

   
   Рисунок 18: Unreal Editor: регулировка поворота

10. Сохраните уровень, указав его имя. Например, я использовал test.umap в папке \ExampleGame\Content\Maps.

    
    Рисунок 19. Unreal Editor: сохранение

11. Скомпилируйте весь проект. В меню выберите Build, затем выберите Build All.

12. Чтобы проверить карту, щелкните Playили нажмите клавиши Alt+F8.

    
    Рисунок 20. Unreal Editor: сборка

13. Сохраните файл и закройте UE Editor.

Можно продолжить изучение использования этого файла карты в качестве источника при добавлении функций Intel RealSense SDK в статье Учебное руководство: использование технологии Intel® RealSense™ в Unreal Engine 3. Часть 2..

Об авторах

Чангйин Ким (Chunghyun Kim) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Он занимается оптимизацией игр и графики в архитектуре Intel®.

Питер Хонг (Peter Hong) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Его специализация — применение Intel RealSense SDK для отслеживания лица и рук, трехмерного сканирования и других целей.

Download PDF 854 KB

GoTutorial: Использование технологии Intel® RealSense™ в Unreal Engine* 3. Часть 1 

В первой части мы создали простую карту игры со структурой костей лица в редакторе Unreal 3. Здесь, во второй части, мы покажем, как использовать возможности Intel RealSense SDKв игре на движке Unreal.

Настройка Visual Studio 2010 для образца игры

Приведенные ниже действия настраивают ваш файл карты в качестве карты по умолчанию для примера игры путем редактирования файла INI.

1. Перейдите в папку \ExmapleGame\Config.
2. Откройте файл DefaultEngine.ini и отредактируйте его, как показано ниже.

[URL]

MapExt=umap

Map=test.umap

LocalMap=BLrealsense_Map.umap

TransitionMap=BLrealsense_Map.umap

EXEName=ExampleGame.exe

DebugEXEName=DEBUG-ExampleGame.exe

GameName=Example Game

GameNameShort=EG

1. Откройте файл ExampleEngine.ini и отредактируйте его, как показано ниже.

   [URL]

   Protocol=unreal

   Name=Player

   Map=test.umap

   LocalMap=BLrealsense_Map.umap

   LocalOptions=

   TransitionMap=BLrealsense_Map.umap

   MapExt=umap

   EXEName=ExampleGame.exe

   DebugEXEName=DEBUG-ExampleGame.exe

   SaveExt=usa

   Port=7777

   PeerPort=7778

   GameName=Example Game

   GameNameShort=EG

2. Откройте файл проекта или решения UE3 Visual Studio в папке \Development\Src – UE3.sln либо откройте UE3.sln в Visual Studio.
   
   Рисунок 1. Microsoft Visual Studio* 2010.

3. Соберите и запустите приложение, как описано ранее. Появится начальное окно Unreal и ваша игра.

Использование системы координат в Unreal Engine

Перед компоновкой с Intel® RealSense™ SDKважно понять систему координат в Unreal.

Положение отслеживается по осям X-Y-Z (см. классы Origin и RotOrigin в исходном коде UE3), а поворот — по эйлеровым углам (P-Y-R) и кватернионам (дополнительные сведения см. в статье https://en.wikipedia.org/wiki/Quaternion for more detail). 

Рисунок 2. Система координат

У кватерниона поворота вокруг поперечной оси — один скалярный множитель и три векторных множителя.

Для преобразования эйлеровых углов в кватернионы

Углы X-Y-Z

Автоматическое расширение установки отладчика в Visual Studio 2010 (необязательно)

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

1. Найдите файл Autoexp.dat.
    

   В Visual Studio под управлением 64-разрядной версии Windows 7 он находится в папке C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\Packages\Debugger.

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

   Папка UE3\ Development/External/Visual Studio Debugging/AUTOEXP.DAT_addons.txt

3. Скопируйте все разделы [AutoExpand] и [Visualizer] в файл Autoexp.dat.

Включение поддержки Intel® RealSense™ SDK в Unreal Engine 3

В этом разделе описываются изменения в Unreal Engine 3, связанные с Intel RealSense SDK. Эти изменения необходимо применить после установки Intel RealSense SDK и Depth Camera Manager. API отслеживания реперных точек на лице и положения головы в Intel RealSense SDK используются для обработки выражения лица и движения головы персонажа. Отслеживание положения головы осуществляется интуитивно, поскольку значения поворота вокруг продольной, поперечной и вертикальной осей можно использовать в Unreal Engine 3 без дополнительных изменений. Отслеживание реперных точек на лице выполняется несколько сложнее.

Рисунок 3.Повороты вокруг трех осей

Intel RealSense SDK предоставляет 76 отслеживаемых точек на лице. Для каждого выражения лица (например, для подмигивания или открытого рта) у соответствующих точек есть определенный диапазон значений. Например, если глаз закрыт, то расстояние между точками 12 и 16 будет близко к 0, а при открытом глазе это расстояние будет больше 0, причем оно будет различаться у разных людей.

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

Рисунок 4.Реперные точки на лице и их номера в Intel® RealSense™ SDK

<UE3> — папка, в которую установлен UE3. Необходимо изменить следующие четыре файла.

• <UE3>\Development\Src\UnrealBuildTool\Configuration\UE3BuildConfiguration.cs
• <UE3>\Development\Src\UnrealBuildTool\Configuration\UE3BuildWin32.cs
• <UE3>\Development\Src\Engine\Inc\UnSkeletalMesh.h
• <UE3>\Development\Src\Engine\Src\UnSkeletalComponent.cpp

UE3BuildConfiguration.cs (необязательно)

public static bool bRealSense = true;

Важные для RealSense коды заключены во фразу «#if USE_REALSENSE». Это предложение используется для определения фразы «#if USE_REALSENSE» в файле UE3BuildWin32.cs. Если изменить код, указав значение false, ссылка на соответствующий код RealSense не будет задействована при компиляции. Это необязательно.

UE3BuildWin32.cs

if (UE3BuildConfiguration.bRealSense)
{
SetupRealSenseEnvironment();
}

void SetupRealSenseEnvironment()
{
      GlobalCPPEnvironment.Definitions.Add("USE_REALSENSE=1");
      String platform = (Platform == UnrealTargetPlatform.Win64 ? "x64" : "Win32");

      GlobalCPPEnvironment.SystemIncludePaths.Add("$(RSSDK_DIR)/include");
      FinalLinkEnvironment.LibraryPaths.Add("$(RSSDK_DIR)/lib/" + platform);

      if (Configuration == UnrealTargetConfiguration.Debug) {
           FinalLinkEnvironment.AdditionalLibraries.Add("libpxc_d.lib");
      } else {
           FinalLinkEnvironment.AdditionalLibraries.Add("libpxc.lib");
      }
}

Определение USE_REALSENSE, которое будет использовано для включения или отключения Intel RealSense SDK в исходном коде (необязательно).

Поскольку Unreal Engine 3 работает на основе makefile, необходимо добавлять файл заголовка Intel RealSense SDK и путь к библиотеке в раздел include проекта и в путь к библиотекам.

UnSkeletalMesh.h

#if USE_REALSENSE
	PXCFaceData* faceOutput;
	PXCFaceConfiguration *faceConfig;
	PXCSenseManager *senseManager;

	void InitRealSense();
	void ReleaseRealSense();
#endif

Это часть объявления классов и функций Intel RealSense SDK. Фрагмент, отвечающий за работу со структурой костей, находится в разделе UpdateSkelPos() файла UnSkeletalComponent.cpp.

UnSkeletalComponent.cpp

#if USE_REALSENSE
	#include "pxcfacedata.h"
	#include "pxcfacemodule.h"
	#include "pxcfaceconfiguration.h"
	#include "pxcsensemanager.h"

	FLOAT rsEyeMin = 6;
	FLOAT rsEyeMax = 25;

	FLOAT rsMouthMin = 5;
	FLOAT rsMouthMax = 50;

	FLOAT rsMouthWMin = 40;
	FLOAT rsMouthWMax = 70;

	FLOAT chMouthMin = -105;
	FLOAT chMouthMax = -75;
……
#endif

Включите файлы заголовков Intel RealSense SDK. Определяет минимальные и максимальные значения пользователя и игровых персонажей. Начинается с rs (значение пользователя) или с ch (значение игрового персонажа). Эти значения должны изменяться в соответствии с внешним видом пользователя и игрового персонажа. Например, при моргании определяется расстояние при открытом и при закрытом глазе, и в соответствующей пропорции эти данные применяются к персонажу игры.

void USkeletalMeshComponent::Attach()
{
……
#if USE_REALSENSE
	senseManager = NULL;
	InitRealSense();
#endif

Функция Attach() вызывает функцию InitRealSense() для инициализации классов, относящихся к Intel RealSense SDK и настройки камеры.

#if USE_REALSENSE
void USkeletalMeshComponent::InitRealSense() {
	if (senseManager != NULL) return;

	faceOutput = NULL;

	senseManager = PXCSenseManager::CreateInstance();
	if (senseManager == NULL)
	{
 // обнаружена ошибка
	}

	PXCSession *session = senseManager->QuerySession();
	PXCCaptureManager* captureManager = senseManager-> QueryCaptureManager();

Функция InitRealSense() указывает, какая камера будет использоваться, и создает соответствующие экземпляры классов для распознавания лиц.

void USkeletalMeshComponent::UpdateSkelPose( FLOAT DeltaTime, UBOOL bTickFaceFX )
{
……
#if USE_REALSENSE
if (senseManager->AcquireFrame(false) >= PXC_STATUS_NO_ERROR) {
	faceOutput->Update();
	int totalNumFaces = faceOutput->QueryNumberOfDetectedFaces();
	if (totalNumFaces > 0) {

Функция UpdateSkelPose() используется для отслеживания положения головы и реперных точек на лице.

// Голова
FVector v(yaw, roll, pitch);

LocalAtoms(6).SetRotation(FQuat::MakeFromEuler(v));
LocalAtoms(6).NormalizeRotation();

Отслеживание положения головы осуществляется интуитивно, поскольку значения поворота вокруг продольной, поперечной и вертикальной осей из Intel RealSense SDK можно использовать без каких-либо дополнительных изменений и вычислений.

Рисунок 5. Реперные точки на лице и номера, используемые при различных выражениях лица (мимика рта, открытые или закрытые глаза)

Для моргания используются реперные точки 12, 16 и 20, 24, а для мимики рта — 47, 51, 33, 39 (подробности реализации зависят от предпочтений разработчиков).

// Рот
FLOAT mouthOpen = points[51].image.y - points[47].image.y;
mouth = chMouthMax - (mouthOpen - rsMouthMin) * mouthRatio;

mouthOpen = points[47].image.x - points[33].image.x;
rMouthWOpen = chMouthWMin + (mouthOpen - rsMouthWMin) * mouthWRatio;

mouthOpen = points[39].image.x - points[47].image.x;
lMouthWOpen = chMouthWMin + (mouthOpen - rsMouthWMin) * mouthWRatio;

cMouth = chMouthCMax - (mouthOpen - rsMouthWMin) * mouthCRatio;

// Левый глаз
FLOAT eyeOpen = points[24].image.y - points[20].image.y;
lEyeInner = chEyeInnerMin + (eyeOpen - rsEyeMin) * innerEyeRatio;
lEyeOuter = chEyeOuterMin + (eyeOpen - rsEyeMin) * outerEyeRatio;
lEyeUpper = chEyeUpperMin + (eyeOpen - rsEyeMin) * upperEyeRatio;

// Правый глаз
eyeOpen = points[16].image.y - points[12].image.y;
rEyeInner = chEyeInnerMin + (eyeOpen - rsEyeMin) * innerEyeRatio;
rEyeOuter = chEyeOuterMin + (eyeOpen - rsEyeMin) * outerEyeRatio;
rEyeUpper = chEyeUpperMin + (eyeOpen - rsEyeMin) * upperEyeRatio;
rEyeLower = chEyeLowerMin + (eyeOpen - rsEyeMin) * lowerEyeRatio;

BN_Lips_Corner_R, BN_Lips_Corner_L, BN_Jaw_Dum используются для мимики рта, а BN_Blink_UpAdd, BN_Blink_Lower, BN_Blink_Inner, BN_Blink_Outer — для моргания. (Номера всех костей см. в разделе «Структура костей лица в примерах персонажей».)

// Рот
FVector m(90, 0, mouth);
LocalAtoms(59).SetRotation(FQuat::MakeFromEuler(m));

LocalAtoms(57).SetTranslation(FVector(mouthWXZ[2], rMouthWOpen, mouthWXZ[3])); // Правая сторона
LocalAtoms(58).SetTranslation(FVector(mouthWXZ[4], lMouthWOpen * -1, mouthWXZ[5])); // Левая сторона

// Левый глаз
LocalAtoms(40).SetTranslation(FVector(eyeXY[0], eyeXY[1], lEyeUpper)); // Верхняя часть
LocalAtoms(41).SetTranslation(FVector(eyeXY[2], eyeXY[3], lEyeLower)); // Нижняя часть
LocalAtoms(42).SetTranslation(FVector(eyeXY[4], eyeXY[5], lEyeInner)); // Внутренняя часть
LocalAtoms(43).SetTranslation(FVector(eyeXY[6], eyeXY[7], lEyeOuter)); // Внешняя часть

// Правый глаз
LocalAtoms(47).SetTranslation(FVector(eyeXY[8], eyeXY[9], rEyeLower)); // Нижняя часть
LocalAtoms(48).SetTranslation(FVector(eyeXY[10], eyeXY[11], rEyeOuter)); // Внешняя часть
LocalAtoms(49).SetTranslation(FVector(eyeXY[12], eyeXY[13], rEyeInner)); // Внутренняя часть
LocalAtoms(50).SetTranslation(FVector(eyeXY[14], eyeXY[15], rEyeUpper)); // Верхняя часть

void USkeletalMeshComponent::ReleaseRealSense() {
	if (faceOutput)
		faceOutput->Release();

	faceConfig->Release();
	senseManager->Close();
	senseManager->Release();
}

Закройте и высвободите все экземпляры соответствующих классов Intel RealSense SDK.

Структура костей лица в примерах персонажей

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

Рисунок 6.Наименования костей

Заключение

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

Об авторах

Чангйин Ким (Chunghyun Kim) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Он занимается оптимизацией игр и графики в архитектуре Intel®.

Питер Хонг (Peter Hong) — инженер по разработке приложений в отделе Intel Software and Services корпорации Intel. Его специализация — применение Intel RealSense SDK для отслеживания лица и рук, трехмерного сканирования и других целей.

Дополнительные сведения

Epic Unreal Engine
https://www.unrealengine.com

Intel RealSense SDK
http://software.intel.com/realsense

Часть 1

Дэниэл Кауфман (Daniel Kaufman)
Сооснователь Brooklyn Labs

Благодаря мобильным приложениям, предназначенным для мобильных ОС, таких как Android, Apple и других, вы можете формировать осведомленность о торговой марке и ее надежности у большого количества существующих и потенциальных покупателей. Многие покупатели сегодня ожидают от компании или торговой марки собственного надежного мобильного приложения. Это значит, что становится необходимым не только наличие объективных преимуществ перед другими компаниями. Специализированное мобильное приложение способствует повышению надежности торговой марки.

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

1. Мобильные приложения обеспечивают динамичную рекламу

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

2. Мир стал мобильным

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

3. Приложения повышают заинтересованность

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

4. Более широкая и молодая аудитория

Большинство молодых людей уже давно стали мобильными. Около 75% возрастной группы миллениалов к концу года будут иметь смартфоны. Очень трудно привлекать представителей молодого поколения, используя несовременные методы. Молодые люди предпочитают полагаться на свои мобильные устройства даже в том случае, если у них есть доступ к устаревшему ПК. Смартфоны становятся новым инструментом для общения с друзьями и близкими, просмотра веб-страниц, покупки товаров и заказа услуг в сети Интернет. Чтобы получить эту аудиторию, вам необходимо иметь мобильное приложение.

5. Это может быть социальная платформа

Не подлежит обсуждению, что люди влюблены в социальные сети. Поэтому вам следует также стать их частью. Добавление социальных функций, таких как «лайки», комментарии и сообщения внутри приложения, направленные на его популяризацию, может помочь компании укрепить свою позицию в социальных сетях. Люди тратят все больше времени на социальные сети, в особенности Facebook и Twitter. Таким образом, наличие мобильного приложения со всеми функциями социальных сетей означает, что они станут проводить в нем все больше и больше времени.