Получение Visual Studio 2015 и цены

Пользователи, у которых активна подписка на Visual Studio Premium с MSDN или Visual Studio Ultimate с MSDN получат автоматический апгрейд до Visual Studio Enterprise с MSDN. Цена на Visual Studio Enteprise с MSDN будет значительно снижена по сравнению с текущей ценой Visual Studio Ultimate с MSDN. Посмотрите раздел Visual Studio 2015 Produt Editions для более детальной информации по ценам, включая действующие предложения по скидкам. Если вы еще не попробовали Visual Studio 2015, самое время сделать это сейчас. Вы можете загрузить Visual Studio 2015 CTP 6 и протестировать новые возможности. Не забывайте оставить свой отзыв с помощью наших ресурсов. (UserVoice, Send-a-Smile, или Connect).

• Это создаст записи в файле WpAppMainfest.xml

  <DefaultLanguage xmlns="" code="en-US" />
  <Languages xmlns="">
    <Language code="en-US" />
    <Language code="ru-RU" />
    <Language code="ru" />
  </Languages>

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

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

1) Create empty unity project:

2)      Create folders in Assets – Plugins and Metro (under Plugins).

3)      We will try to call plugin function from empty GameObject. Create it:

4)      And create C# script:

5)      Then bind it to empty GameObject (by drag&dropping script to Inspector window).

6)      Now check, that everything is ok:

7)      Play scene and notice log message from console:

8)      Now it’s time to create Windows 8 Runtime plugin. Create new Windows Store apps library. I recommend to do it in unity project folder:

9)      Configure paths for output:

10)   And check that everything is ok – compile project and check Assets/Plugins/Metro folder from Unity:

11)   Now add additional project (windows class library) to this solution – Stub dll that runs under unity editor.

12)   Stub contains only design time functions, but can share most of our plugin code. To reference original plugin.cs, create link from "Add existing File Menu" in this project as link. (Tanks Adam Tuliper for tip).

13)   Next step is make some changes of project properties. Make assembly name and default namespace same as WinRTPlugin project and change target framework to version 3.5.

14)   Also point output dir to Assets/Plugins

15)   Delete reference to Microsoft.CSharp assembly:

16)   Close plugin.cs editor tab and doubleclick plugin.cs from Stub project, and surround references from Windows Runtime using NETFX_CORE condition.

17)   Now, build Stub project and check that output dll placed to Assets/Plugins.

18)   It’s time to call our plugin function. Edit your unity script and add plugin instance & function call:

19)   Open plugin.cs from WinRTPlugin project and add some windows 8 functions:

20)   Build you project from Unity:

21)   Open your unity solution from Visual Studio and check that it references WinRTPlugin.dll:

22)   Run your app and check that everything is ok:

You can download sample code from here https://sdrv.ms/18LcwIo
 

Но вы зря волнуетесь по этому поводу, Visual Studio содержит эффективный инструмент под названием Javascript Memory Analysis, который помогает обнаружить утечки памяти.

Рекомендации по применению инструмента Javascript Memory Analysis

Этот инструмент запускается из меню Debug (Отладка) в Visual Studio:

После запуска инструмента, запустится и ваше приложение, на экране вы увидите следующее:

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

Ниже присутствует кнопка Take Heap Snapshot (Создание мгновенного снимка кучи), используемая для создания мгновенного снимка «кучи» (элемент управления также показывает размер «кучи» и количество активных объектов):

По щелчку на размере «кучи» выводится более подробная информация:

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

На примере моего приложения, я вижу, что объект UrzaGatherer удерживает около 60 МБ памяти (так и должно быть, поскольку в нем хранится огромный список карт):

Это представление также позволяет вывести на экран:

• список типов, отсортированный по количеству вхождений;
• список корневых объектов (с точки зрения сборщика мусора);
• список объектов DOM, отсортированный по объему удерживаемой памяти;
• список объектов WinRT, отсортированный по объему удерживаемой памяти.

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

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

После каждого нажатия кнопки Take Heap Snapshot (Создание мгновенного снимка кучи) система генерирует новый дамп «кучи» с целью последующего анализа. Кроме того, каждый новый снимок позволяет оценить динамику изменения размера «кучи» и количества объектов.

Это основной инструмент поиска утечек памяти.

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

Сравнив два моментальных снимка, я обнаружил, что размер «кучи» увеличился на 6,12 МБ, кроме того, были созданы 53 000 объектов, которые не были в дальнейшем удалены. 

Щелкнув значение, показывающее изменение размера «кучи» (+6,12 МБ), вы можете получить более подробную информацию о различиях между двумя моментальными снимками:

Представление Dominators (Доминаторы) показывает, что новые объекты не были удалены после того, как мы вернулись на домашнюю страницу. Это представление поможет вам обнаружить ненужные объекты.

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

Как видите, объект удерживается функцией ImportFromTappedOut.

Эта глобальная функция в моем коде принимает функцию в качестве параметра:

ImportFromTappedOut = function (deckName, custom) {

Параметр custom эта функция использует для вызова специализированного пользовательского кода. Главная проблема связана с тем, что ImportFromTappedOut — глобальная функция, и она хранит весь код, к которому обращается функция, в параметре custom. В этом случае моя анонимная функция ссылается на большое количество локальных объектов DOM:

Tools.ImportFromTappedOut("test", function () { var select = document.querySelector("#addToDeck"); 
 var count = document.querySelector("#addToDeckCount").value; 
 listView.selection.getItems().then(function (items) { appBar.hide(); 
 appBar.sticky = false; listView.selection.clear();

…code continue…

Эту проблему мне помог обнаружить рассматриваемый инструмент:

Решение простое: достаточно вызвать importFromTappedOut с нулевой функцией, когда я закрываю страницу, чтобы сборщик мусора удалил все сохраненные объекты (в этом случае освободится 1,25 МБ).

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

Подробнее о рассматриваемом инструменте

Следующие статьи также могут быть вам полезны:

• JavaScript memory analysis for Windows Store apps in Visual Studio 2012
• Optimizing JavaScript Windows 8 application: Using the Visual Studio performance analysis tool (profiler)
• How to cook a Windows 8 application with HTML5/Javascript/CSS3
• Unleash the power of HTML 5 Canvas for gaming
• [Французский]https://www.microsoft.com/france/mstechdays/programmes/2013/fiche-session.aspx?ID=f721312a-cc92-4599-8795-cfe07d5c0bb4

Варианты применения инструмента IntelliTrace:

1. Во время отладки в VS нажатием клавиши F5.
2. В Test Manager (доступен как адаптер диагностических данных — Data Diagnostic Adapter).
3. При запуске из любого места (использование автономного сборщика данных).

Описание «режимов работы» IntelliTrace

В IntelliTrace реализовано два стандартных режима с широкими возможностями: Events Only (Только события) и Events and Call Information (События и сведения о вызовах). Режим Events Only — упрощенный, он позволяет регистрировать «события», которые происходят во время выполнения вашей программы. Эти события представляют собой заслуживающие интереса «происшествия», например вызовы ASP.NET или ADO.NET, а также исключения. Группа разработки продукта постаралась записать события, которые помогут понять, как ваш код работает, и проследить длинные цепочки «причин и следствий».

Режим Events and Call Information — расширенный режим отладки, при котором помимо сведений, относящихся к режиму Events Only, регистрируются также вызовы методов (включая входящие и исходящие аргументы). Для подлежащих сбору данных установлены некоторые ограничения, иначе размер журналов будет просто огромным, даже больше, чем с настройками по умолчанию.

Использование клавиши F5 при работе с IntelliTrace

Этот вариант подходит для использования в процессе разработки кода. Это означает, что можно отлаживать приложение, перемещаясь вперед и назад в сеансе отладки, при этом нет необходимости останавливать приложение или добавлять точки останова. Активировать отладчик можно в настройках IntelliTrace: Tools -> Options (Сервис -> Параметры). Предусмотрено два режима:

После активации (в данном случае я включил режим Events and Call Information) отладчик готов к использованию. Понажимайте кнопки в своем приложении и щелкните ссылку Break All (Приостановить все) в VS в окне IntelliTrace:

(Я отлаживаю свое приложение Calculator. Нажимаю Break All (Приостановить все) и открывают журнал IntelliTrace.)

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

Предположим, что нечто странное произошло, когда я нажал «=», перемножая два числа. Перезапускать приложение нет необходимости, я могу просто нажать кнопку «=» после «*» (из записи в журнале видно, что я нажал 3 х 6 =). Я могу нажать это событие и «перемотать» до интересующего меня момента.

Сейчас я могу нажать Calls View (Представление вызовов) и приступить к просмотру журнала с этой точки.

Дважды щелкните вызов btnEqual_Click для перехода к этому моменту выполнения. Вы увидите глифы IntelliTrace во внутреннем поле окна исходного кода:

Если навести указатель мыши на значки, система выдаст подсказку. Функции появляются в следующем порядке:

· return to calling method

· step back

· step into

· step over

· return to Live Debugging

(Небольшая подсказка: при нажатии кнопки return to Live Debugging (Возврат к динамической отладке) внизу, вы перейдете к текущей точке отладчика, и для повторного запуска приложения следует опять нажать клавишу F5.)

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

Обратите внимание: мне не придется гадать, какой именно оператор Case был выбран, достаточно посмотреть запись в журнале. Я также поставил метки для обработчиков наведения и убирания курсора мыши для val1 и val2, вы можете увидеть эти значения. Не все значения отслеживаются, но в данном случае это исходящие или входящие примитивы метода, поэтому IntelliTrace успешно регистрирует их значения.

Я опять нажму клавишу F11, чтобы войти в метод Multiply(), а затем еще раз, чтобы перейти к следующему событию:

Я перешел к закрывающейся фигурной скобке метода Multiply. В окне Autos показаны параметры val1 и val2 и их значения (3 и 6, соответственно), а также значение, возвращаемое методом (9).

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

Фильтрация событий

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

Например, в выпадающем списке All Categories (Все категории) я могу выбрать фильтр, чтобы отображались только исключения:

Поиск строки

Также рекомендую использовать функцию поиска строки (Search For this line) или метода (Search For This Method). Вы подозреваете, что метод был выполнен во время отладки, но читать весь журнал нет времени? Никаких проблем! Щелкните правой кнопкой мыши строку (или метод) и выберите Search For This Line/Method in IntelliTrace (Поиск для этой строки/метода в IntelliTrace).

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

Я щелкну по значку стрелки сразу после слова Multiply, чтобы перейти к первому вызову этого метода в журнале и начать процесс «отладки» с этого места.

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

Удачной отладки!

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

Если вам легче воспринимать визуальную информацию, то посмотрите видеоролики для части 1 и 2 на нашем канале Channel 9! Вам понадобится менее получаса, чтобы с нуля создать приложение, реалистично имитирующее игру в кости!

Заключительные шаги Windows RT

Современные устройства с Windows RT оборудованы графической картой с поддержкой D3D_FEATURE_LEVEL_9_1, а инструменты Visual Studio Graphics генерируют шейдеры для графических карт с поддержкой D3D_FEATURE_LEVEL_10_0 и выше, поэтому для того, чтобы приложение можно было запускать на устройствах с Windows RT, необходимо создать шейдеры поддерживаемой версии.

Откройте сетку Die (Die.fbx) и щелкните куб. В окне Properties (Свойства) найдите свойство Effect (Эффект). Нажмите кнопку «+» слева от этого свойства и выберите значение Advanced (Расширенные). Наконец, нажмите кнопку «…», чтобы открыть исходный код шейдера для эффекта Phong (метод Фонга).

В окне конструктора шейдеров Visual Studio Shader Designer вы увидите шейдер, который по умочанию применяется к этой сетке в Visual Studio. Конструктор шейдеров позволяет создавать сложные визуальные эффекты, при этом вам не придется изучать новый язык программирования. Подробнее о конструкторе шейдеров написано в документации и обзоре на сайте MSDN.

Мы экспортируем этот шейдер в HLSL для того, чтобы перекомпилировать его для видеокарт типа Direct3D Feature Level 9. Starter Kit попытается автоматически найти поддерживаемый шейдер с тем же именем, если оригинал не поддерживается данным устройством.

Для экспорта этого шейдера переходим к последнему значку на панели инструментов: (Advanced) -> Export -> Export as… ((Расширенные) -> Экспортировать -> Экспортировать как...), вводим имя Phong.hlsl и сохраняем файл в папку Assets (см. рисунок ниже). Необходимо добавить этот файл в проект: щелкните правой кнопкой мыши папку Assets, нажмите Solution Explorer -> Add -> Existing item (Обозреватель решений -> Добавить -> Существующий элемент) и выберите только что экспортированный файл.

Наконец, мы должны сообщить компилятору HLSL, что этот файл относится к типу Pixel Shader (Шейдер пикселей). Для этого в обозревателе решений Solution Explorer щелкните правой кнопкой мыши файл Phong.hlsl и выберите Properties (Свойства). На странице свойств проверьте, чтобы в раскрывающемся списке Configuration (Конфигурация) был выбран пункт All Configurations (Все конфигурации), а в раскрывающемся списке Platform (Платформа) — All Platforms (Все платформы). Таким образом, все вносимые нами изменения применяются ко всем версиям нашего приложения.

Затем на странице HLSL Compiler (Компилятор HLSL) задайте свойству Shader Type (Тип шейдера) значение Pixel Shader (/ps) [Шейдер пикселей (/ps)]. Кроме того, должна быть включена оптимизация, т. е. свойству Disable optimizations (Отключить оптимизацию) должно быть задано значение No (Нет). Эти настройки показаны на рисунке ниже:

На этом этапе мы подготовили приложение для запуска на устройствах под управлением Windows RT. Теперь вы можете установить это приложение на своем устройстве с помощью инструментов удаленной отладки Visual Studio Remote Debugging Tools.

Прежде чем опубликовать версию приложения для Windows RT, необходимо убедиться в том, что и портретный режим, и режим Snap View работают корректно. В этом случае мы просто удалили следующую строку из метода CreateWindowSizeDependentResource() в классе Game.cpp, чтобы камера не меняла ориентацию при переключении режима представления:

void Game::CreateWindowSizeDependentResources()
 {
 GameBase::CreateWindowSizeDependentResources();
 
 // (фрагмент) инициализировать камеру...
 if (aspectRatio < 1.0f)
 {
 ///
 /// портретный режим или режим snap view
 ///
 m_graphics.GetCamera().SetUpVector(XMFLOAT3(1.0f, 0.0f, 0.0f)); 
 fovAngleY = 120.0f * XM_PI / 180.0f;
 }
 // (фрагмент) источники света...
 }

Приложение в его текущем состоянии можно загрузить с сайта CodePlex (см. прямую ссылку ниже).

Портирование приложения на Windows Phone

Проект Starter Kit with support for Windows Phone позволяет беспрепятственно портировать это приложение на Windows Phone 8. Теперь необходимо загрузить пакет Starter Kit, заменить классы Game.cpp и Game.h на те, которые вы создали для этого приложения, добавить все свои активы (в данном случае: Die.fbx, DieTexture.png и Phong.hlsl), а также внести изменения в код XAML для вызова метода RollDie(), когда пользователь касается сенсорного экрана. Краткие пошаговые инструкции:

1. На вашем компьютере должен быть установлен пакет Windows Phone 8 SDK.
2. Загрузите пакет Visual Studio 3D Starter Kit with support for Windows Phone и откройте его в Visual Studio.
3. В проекте StarterKitPhoneComponent: удалите папку Shared/Animation и все содержимое из папки Shared/Assets.
4. Замените файлы Game.cpp и Game.h на созданные вами ранее.
5. Скопируйте все активы вашей игры в папку Shared/Assets проекта StarterKitPhoneComponent: Die.fbx, DieTexture.png и Phong.hlsl.
6. На странице свойств файла Phong.hlsl проверьте, чтобы в раскрывающемся списке Configuration (Конфигурация) был выбран пункт All Configurations (Все конфигурации), а в раскрывающемся списке Platform (Платформа) — All Platforms (Все платформы). Затем на странице HLSL Compiler (Компилятор HLSL) задайте свойству Shader Type (Тип шейдера) значение Pixel Shader (/ps) [Шейдер пикселей (/ps)] и установите для свойства Disable optimizations (Отключить оптимизацию) значение No (Нет).
7. Удалите неиспользуемые методы из класса Direct3DBackground.cpp/.h: ToggleHitEffect() и ChangeMaterialColor().
8. В классе Direct3DBackground.cpp добавьте следующий код в метод OnPointerReleased():

   void Direct3DBackground::OnPointerReleased(DrawingSurfaceManipulationHost^ sender, PointerEventArgs^ args)

   {

     m_renderer->RollDie();

   }

9. Из MainPage.xaml удалите весь код XAML, относящийся к счетчикам и панели приложения.
10. Из MainPage.xaml.cs удалите все неиспользуемые поля и методы.

Готово! Теперь это приложение можно запустить в эмуляторе Windows Phone или на устройстве с Windows Phone 8. Вы можете отрегулировать положение камеры и поле зрения, чтобы на экране телефона ��убик выглядел крупнее.

Итоговую версию проекта можно загрузить с сайта CodePlex (см. прямую ссылку ниже).

Планы на будущее

Это приложение готово к размещению в Магазине Windows, но есть много дополнительных шагов, которые помогли бы сделать его лучше. Например:

• Замена логотипа, иконок плитки и заставки в соответствии с темой приложения.
• Создание красивого фона и, возможно, стола, на который пользователь будет бросать кости.
• Добавление теней, отражения и других реалистичных визуальных эффектов.
• Можно сделать кубик настраиваемым, полупрозрачным, с закругленными краями.
• Обеспечение поддержки более чем одного кубика или кубиков с разным количеством граней.
• Добавление реалистичных подпрыгиваний и вращений с учетом силы броска, обнаружение столкновений.
• Сохранение информации о состоянии кубика, когда работа приложения приостанавливается и возобновляется.
• Ведение истории результатов предыдущих бросков.
• Обеспечение поддержки датчика, чтобы пользователь мог бросать кости путем встряхивания устройства.
• Звуковое сопровождение броска костей.
• Возможности приложения Dice Roller можно использовать для создания настольной игры или симулятора казино...

Подведем итоги

Эта серия статей познакомила вас с процессом создания 3D-приложения для Windows 8, Windows RT и Windows Phone с использованием пакета Visual Studio 3D Starter Kit. Вся логика и активы приложения являются кроссплатформенными. Также вы узнали об инструментах Visual Studio Graphics и поняли, что создание 3D-приложения — не такая уж сложная задача, вы можете приступать к ней без глубоких знаний в области трехмерного моделирования, математики и HLSL, постепенно изучая новые понятия.

Мы будем рады услышать отзывы об этом пошаговом руководстве, пакете Visual Studio 3D Starter Kit, а также узнать, с какими возможностями Visual Studio, предназначенными для работы с графикой, вы хотели бы познакомиться в будущем. Оставляйте нам свои комментарии!

Как заставить кубик крутиться

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

1. Определить какое-либо состояние (например, с помощью логического флага), чтобы указать, что должна быть запущена анимация. Также на этом этапе можно сохранить сведения об исходном положении и продолжительности анимации, если это необходимо.
2. В методе Update, который вызывается для каждого кадра перед рендерингом, обрабатывается положение/вращение/масштабирование объекта (с точки зрения 3D-модели, мы говорим о преобразованиях); следует вычислить разницу во времени между началом анимации и выводом на экран текущего кадра. Когда анимация завершается, необходимо надлежащим образом обновить состояние, чтобы остановить анимацию.
3. В методе Render преобразования должны применяться к каждому объекту надлежащим образом.

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

Чтобы создать эту анимацию, нам понадобится набор переменных для отслеживания преобразований куба, а также времени анимации. Мы создадим одну переменную типа Boolean для отслеживания выполнения анимации, одну переменную типа Float для хранения времени анимации и три вектора для хранения начального, конечного и текущего вращений куба. Векторы типа XMFLOAT3 будут хранить вращения Yaw, Pitch и Roll (см. рисунок ниже).

Давайте создадим эти поля и метод RollDie(). Добавьте следующий код в класс Game.h:

ref class Game sealed : public GameBase
 {
 // (фрагмент) объявление других классов...
 
 Platform::String^ OnHitObject(int x, int y);
 void RollDie(); 
 private:
 std::vector<VSD3DStarter::Mesh*> m_meshModels;
 bool m_isAnimationRunning;
 float m_animationTime;
 DirectX::XMFLOAT3 m_initialRotation;
 DirectX::XMFLOAT3 m_currentRotation;
 DirectX::XMFLOAT3 m_targetRotation;
 };

Давайте создадим анимацию, начнем с метода RollDie(). Добавьте следующий код в класс Game.cpp:

void Game::RollDie()
{
    m_initialRotation = m_currentRotation;
    m_targetRotation = XMFLOAT3(0.0f, XM_PI, 0.0f); // always rotate to 6

    m_animationTime = 0.0f;
    m_isAnimationRunning = true;
}

RollDie() запустит анимацию путем задания значения True для переменной m_isAnimationRunning. Нам необходимо добавить код в метод Update() для поворота куба в каждом кадре. Добавьте следующий код в метод Update(): 

void Game::Update(float timeTotal, float timeDelta)
 {
 if (m_isAnimationRunning)
 {
 m_animationTime += timeDelta;
 
 static const float animationDuration = 0.5f;
 float animationProgress = std::min<float>(m_animationTime / animationDuration, 1.0f);
 
 XMVECTOR initial = XMLoadFloat3(&m_initialRotation);
 XMVECTOR target = XMLoadFloat3(&m_targetRotation);
 
 XMVECTOR current = initial + animationProgress * (target - initial);
 XMStoreFloat3(&m_currentRotation, current);
 
 if (animationProgress >= 1.0f)
 m_isAnimationRunning = false;
 }
 }

Описание кода:

1. Анимация должна запускаться только в том случае, когда установлен флаг m_isAnimationRunning.
2. Сначала вычисляется значение переменных calculate m_animationTime (время от начала анимации 0–0,5 секунды) и m_animationProgress (процент завершения анимации 0–1). Обратите внимание, «1.0» означает, что анимация завершена.
3. Загрузите исходный и целевой векторы вращения в XMVECTORs, это позволяет ускорить расчеты благодаря макроопределениям CPU.
4. Расчеты линейным способом по формуле:

текущий = исходный + прогресс * (целевой – исходный)

1. Вычисленное значение сохраняется обратно в m_currentRotation.
2. Проверка выполнения анимации и ее остановка в случае необходимости.

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

void Game::Render()
 {
 GameBase::Render();
 
 // (фрагмент) очистить...
 
 XMMATRIX transform = XMMatrixRotationRollPitchYawFromVector(XMLoadFloat3(&m_currentRotation));
 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 }
 
 // (фрагмент) MSAA...
 }

Метод, который мы вызываем, получает объект XMVECTOR, содержащий значения переменных для разворота, уклона и поворота относительно вертикальной оси. Этот метод возвращает матрицу вращения, которая соответствует комбинированному преобразованию. Для наших целей также подходит метод XMMatrixRotationRollPitchYaw, который обрабатывает параметры разворота, уклона и поворота относительно вертикальной оси по отдельности. Кроме того, вы можете вычислить каждый компонент с помощью отдельного метода, а затем самостоятельно перемножить результаты. Полный перечень методов, используемых для создания матриц преобразования, представлен на сайте MSDN.

Все, что нам необходимо сделать,— вызвать метод RollDie(). Мы будем вызывать его каждый раз, когда пользователь касается или щелкает по экрану. Добавьте следующий код в файл DirectXPage.xaml.cpp (в метод DirectXPage::OnTapped):

void DirectXPage::OnTapped(Platform::Object^ sender, TappedRoutedEventArgs^ e)
 {
 m_renderer->RollDie();
 }

Если вы запустите приложение сейчас, то после щелчка или касания экрана в любом месте кубик будет вращаться, показывая цифры от 1 до 6!

Логика приложения: генератор случайных чисел

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

Сначала генератор rand() нужно инициализировать с помощью некоторого начального значения. Если мы не инициализируем генератор или инициализируем его с использованием фиксированного значения, то последовательность генерируемых чисел будет неизменна при каждом запуске приложения, а нам это не подходит. Мы будем инициализировать генератор случайных чисел с использованием текущего времени CPU. Добавьте следующий код в метод Game::Initialize():

void Game::Initialize()
 {
 Mesh::LoadFromFile(m_graphics, L"die.cmo", L"", L"", m_meshModels);
 
 srand ((unsigned int) time(NULL));
 }

Также следует подключить библиотеку <time.h> для метода Game.cpp, чтобы функция time() была доступна:

#include "pch.h"
 #include "Game.h"
 #include <DirectXMath.h>
 #include <DirectXColors.h>
 #include <algorithm>
 #include <time.h>

После инициализации мы можем воспользоваться функцией rand() в методе RollDie(), чтобы получить цифру, которая выпадет, когда пользователь бросит кости. Мы также должны правильно задать целевые вращения кубика при каждом броске. Для этого измените строку, в которой задается значение переменной m_targetRotation. Окончательный вариант метода RollDie():

void Game::RollDie()
 {
 m_initialRotation = m_currentRotation;
 
 int currentRoll = rand() % 6 + 1;
 switch (currentRoll)
 {
 case 1:
 m_targetRotation = XMFLOAT3(0.0f, 0.0f, 0.0f);
 break;
 case 2:
 m_targetRotation = XMFLOAT3(0.0f, XM_PIDIV2, 0.0f);
 break;
 case 3:
 m_targetRotation = XMFLOAT3(XM_PIDIV2, 0.0f, 0.0f);
 break;
 case 4:
 m_targetRotation = XMFLOAT3(-1.0f * XM_PIDIV2, 0.0f, 0.0f);
 break;
 case 5:
 m_targetRotation = XMFLOAT3(0.0f, -1.0f * XM_PIDIV2, 0.0f);
 break;
 case 6:
 m_targetRotation = XMFLOAT3(0.0f, XM_PI, 0.0f);
 break;
 }
 
 m_animationTime = 0.0f;
 m_isAnimationRunning = true;
 }

Запустите приложение. Вот наш анимированный кубик! Бросьте кости, коснувшись экрана в любом месте. Можете перейти в режим Snap View.

Как заставить кубик прыгать

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

Чтобы запрограммировать «прыжки», мы добавим еще одну переменную в нашу анимацию — вертикальную координату (Y). Значение этой переменной будет изменяться после того, как кости будут брошены (в методе Update()), мы также внесем изменения в метод Render(), чтобы применить трансляцию к кубу. Сначала нужно добавить переменную трансляции в Game.h:

ref class Game sealed : public GameBase
 {
 // (фрагмент) объявление других классов...
 
 private:
 std::vector<VSD3DStarter::Mesh*> m_meshModels;
 bool m_isAnimationRunning;
 float m_animationTime;
 DirectX::XMFLOAT3 m_initialRotation;
 DirectX::XMFLOAT3 m_currentRotation;
 DirectX::XMFLOAT3 m_targetRotation;
 float m_currentTranslationY;
 };

Чтобы переменная изменялась с течением времени (метод Update()):

void Game::Update(float timeTotal, float timeDelta)
 {
 if (m_isAnimationRunning)
 {
 // (фрагмент)
 
 XMVECTOR current = initial + animationProgress * (target - initial);
 XMStoreFloat3(&m_currentRotation, current);
 
 const float maxHeight = 2.0f;
 m_currentTranslationY = 4.0f * maxHeight * animationProgress * (1 - animationProgress);
 
 if (animationProgress >= 1.0f)
 m_isAnimationRunning = false;
 }
 }

Те, кто помнит курс математики старших классов, узнали уравнение параболы с полюсами в точках 0 и 1 и вершиной в точке 0,5 (MaxHeight). Наш кубик будет достаточно реалистично подпрыгивать. График этой функции можно увидеть здесь: WolframAlpha.

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

v

oid Game::Render()
 {
 // (фрагмент) очистить...
 
 m_d3dContext->ClearDepthStencilView( /* (фрагмент) */ );
 
 XMMATRIX transform = XMMatrixRotationRollPitchYawFromVector(XMLoadFloat3(&m_currentRotation));
 transform *= XMMatrixTranslation(0.0f, m_currentTranslationY, 0.0f);
 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 }
 
 // (фрагмент) MSAA...
 }

Запустите приложение и щелкните по экрану. Вы увидите, что кубик после броска реалистично подпрыгивает. Наконец, чтобы анимация выглядела еще более реалистичной, добавим случайные вращения по обеим осям при каждом броске кубика. Для этого внесем изменения в метод RollDie() и добавим случайные повороты в целевое вращение:

void Game::RollDie()
 {
 // (фрагмент) инициализация, бросок и переключение(currentRoll)
 
 XMVECTOR target = XMLoadFloat3(&m_targetRotation);
 XMVECTOR current = XMLoadFloat3(&m_currentRotation);
 
 // учет текущего вращения
 target += XMVectorFloor(current / XM_2PI) * XM_2PI;
 
 // -1, 0 или 1 дополнительный оборот
 XMVECTOR randomVector = XMLoadFloat3(&XMFLOAT3(rand() % 3 - 1.0f, rand() % 3 - 1.0f, rand() % 3 - 1.0f));
 target += randomVector * XM_2PI;
 
 XMStoreFloat3(&m_targetRotation, target);
 
 m_animationTime = 0.0f;
 m_isAnimationRunning = true;
 }

Этот код вносит два изменения в целевое вращение:

1. Указывается общее количество полных оборотов, совершенных до настоящего момента в рамках целевого вращения, в результате чего каждый поворот будет выполняться относительно предыдущего поворота, а не исходного положения кубика.
2. Добавляется -1, 0 и 1 полный оборот к целевому относительному вращению. Для этого мы создаем вектор на основе трех значений, выбранных случайно из ряда -1, 0 и 1, и умножаем полученную величину на 2 * PI (полный оборот в радианах).

Также обратите внимание на то, что мы используем XMVECTORs еще раз для ускорения расчета, это также позволяет использовать только одну формулу вместо трех (если бы компоненты х, у, z вычислялись по отдельности).

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

Осталось всего несколько шагов, и наше приложение будет работать на устройствах с Windows RT и Windows Phone. Эти шаги мы рассмотрим в третьей и последней статье блога из этой серии. Следите за обновлениями!

Несколько недель назад мы анонсировали серию статей, в которых будет показан весь процесс разработки приложения с использованием пакета Visual Studio 3D Starter Kit. Представляем вашему вниманию первую статью из этой серии. В серии статей мы рассмотрим процесс разработки приложения, пользователь которого сможет касанием или щелчком бросать трехмерные шестигранные кубики для игры в кости. Брошенный кубик будет подпрыгивать и вращаться в воздухе. Это приложение будет также запускаться в режиме Snap View в Windows 8, и пользователи смогут бросать кости, не прерывая работу в других приложениях. Мы также продемонстрируем, как сделать это приложение совместимым с устройствами на базе Windows RT, а также портировать его на Windows Phone.

В первой статье мы рассмотрим процесс создания приложения до этапа вывода кубика на экран и наложения текстуры. Мы также изучим возможности инструментов Visual Studio Graphics, которые доступны, начиная с версии Visual Studio Professional и выше. Но даже если у вас только Visual Studio Express 2012 для Windows 8, вы все равно сможете работать с этим пошаговым руководством.

Самые большие сложности у начинающих разработчиков Direct3D возникают из-за необходимости изучения большого количества новых понятий, например они должны научиться кодировать шейдеры HLSL и конвертировать сетки в форматы, подходящие для использования в режиме выполнения. Visual Studio содержит большое количество инструментов, упрощающих этот процесс, они помогут вам сконцентрироваться на логике приложения, вместо того чтобы изучать эти новые понятия. Когда вы будете готовы, вы сможете реализовать дополнительные функции в своем приложении, и при этом не придется начинать все сначала. В статьях из этой серии присутствует ряд ссылок на дополнительную документацию по DirectX, которую мы сами используем. Вы можете изучить эти материалы самостоятельно и узнать подробнее о DirectX и программировании графики.

Итак, настало время перейти от слов к делу!

Демонстрационное приложение Dice Roller, имитирующие бросание игральных костей

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

Ну конечно! Мы можем сделать кубик трехмерным! При этом мы не будем использовать какие-либо дополнительные инструменты, только Visual Studio 2012 Professional. Приступим!

Начинаем с чистого листа

Сначала необходимо загрузить и открыть пакет Visual Studio 3D Starter Kit. Ссылка для загрузки: https://aka.ms/vs3dkit. Мы также подготовили специальную версию пакета Starter Kit (только для Магазина Windows) для этого руководства. Сначала у вас будет совершенно пустой экран, без трехмерных моделей. Таким образом, мы научимся создавать собственные активы. Загрузить эту версию можно с сайта CodePlex, (прямая ссылка представлена на плитке ниже). Вы также поймете, как удалить все содержимое из Starter Kit.

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

После запуска этого приложения вы увидите заставку Starter Kit с чайником, а затем — пустой серый экран. Не волнуйтесь, мы скоро его заполним…

Создание и отображение сетки

Сначала мы создадим единственную сетку, которую мы будем использовать в этом приложении,— трехмерный куб для костей. Для этого в окне обозревателя решений Visual Studio Solution Explorer правой кнопкой мыши щелкните папку Shared/Assets (Общие/Активы) в проекте StarterKit и выберите Add -> New item… -> Graphics -> 3D Scene (.fbx) (Добавить -> Новый элемент… -> Графика -> 3D-сцена (.fbx)). Давайте назовем сцену Die.fbx. На следующем рисунке показано окно редактора сетки Visual Studio Mesh Editor:

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

Чтобы вывести куб на экран, в нашу игру необходимо добавить код для загрузки и рендеринга сетки. В Starter Kit присутствует класс Game (Game.cpp/Game.h), который содержит логику рендеринга для нашей игры, именно сюда этот код должен быть добавлен.

Для начала загрузим сетку из файла при инициализации приложения. Добавьте следующий код в метод Game::Initialize(): 

void Game::Initialize()
 {
 Mesh::LoadFromFile(m_graphics, L"die.cmo", L"", L"", m_meshModels); 
 }

Этот код использует класс Mesh из проекта Starter Kit для загрузки модели Die из файла в вектор m_meshModels.

• Первый параметр, m_graphics, содержит экземпляр класса Graphics, в который сгруппированы все полезные объекты DirectX.
• Второй параметр — это имя файла. Файл имеет расширение .cmo, поскольку в ходе построения все активы преобразуются в более простой формат, оптимальный для режима выполнения. Откомпилированные сетки хранятся в файлах в формате CMO (Compiled Mesh Object), для шейдеров используется стандартный компилятор FX, который создает файлы в формате CSO (Compiled Shader Object), изображения (PNG, JPG и т. д.) будут преобразованы в оптимизированный для среды выполнения формат DDS (DirectDraw Surface).
• Третий и четвертый параметры содержат относительные пути к шейдерам (файлам CSO) и текстурам (файлам DDS), которые используются в этой сетке. Чаще всего подходят значения по умолчанию.
• Последний параметр — это ссылка на вектор std::vector класса Meshes, где должны храниться загруженные сетки.

Далее необходимо выполнить рендеринг куба в каждом кадре. Добавьте следующий код в метод Game::Render():

void Game::Render()
 {
 GameBase::Render();
 
 // clear
 m_d3dContext->OMSetRenderTargets(
 1,
 m_d3dRenderTargetView.GetAddressOf(),
 m_d3dDepthStencilView.Get()
 );
 
 m_d3dContext->ClearRenderTargetView(
 m_d3dRenderTargetView.Get(),
 DirectX::Colors::DarkSlateGray
 );
 
 m_d3dContext->ClearDepthStencilView(
 m_d3dDepthStencilView.Get(),
 D3D11_CLEAR_DEPTH,
 1.0f,
 0
 );
 
 XMMATRIX transform = XMMatrixIdentity(); 
 for (UINT i = 0; i < m_meshModels.size(); i++)
 {
 m_meshModels[i]->Render(m_graphics, transform);
 } 
 
 //
 // only enable MSAA if the device has enough power
 //
 if (m_d3dFeatureLevel >= D3D_FEATURE_LEVEL_10_0)
 {
 // (... MSAA code ...)
 }
 }

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

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

Вам не кажется, что кубик маловат? Давайте приблизим камеру. Добавьте следующую строку в метод Game::CreateWindowSizeDependentResources(): 

m_graphics.GetCamera().SetPosition(XMFLOAT3(0.0f, 2.0f, -6.0f));

Этот метод вызывается каждый раз, когда изменяются размеры окна (например, при изменении разрешения или в режиме Snap View), поэтому здесь удобно задавать и изменять свойства камеры. Строка, в которую мы внесли изменения, устанавливает положение камеры, кроме того, можно отрегулировать поле зрения (fovAngleY в коде проекта StarterKit), тогда объекты визуально будут больше или меньше, а положение камеры не изменится.

Добавление текстуры

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

На рисунке ниже показана предлагаемая текстура. Текстуру можно загрузить отсюда.

Сначала необходимо скопировать файл в папку Assets. Вернитесь в Visual Studio, щелкните правой кнопкой мыши папку Assets, нажмите Add -> Existing item (Добавить -> Существующий элемент) и выберите изображение.

Наконец, нужно применить текстуру к кубу. Откройте сетку Die (Die.fbx) и щелкните куб. В окне инструмента Properties (сочетание клавиш: Alt+Enter) найдите свойство Texture1. Нажмите кнопку «…», чтобы выбрать изображение и применить его к кубу.

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

Приложение в его текущем состоянии можно загрузить с сайта CodePlex (прямая ссылка представлена на плитке ниже).

В нашей следующей статье мы расскажем, как добавить код анимации и сделать так, чтобы кубик можно было бросать! До встречи!

Dice Roller Assets.zip

Сейчас я расскажу вам, как ваше приложение может воспользоваться возможностями службы расположения для предоставления пользователям информации с учетом их местоположения, которое определяется по IP-адресу, параметрам сети Wi-Fi или данным GPS. После определения местоположения вы можете предоставить эту информацию пользователю с помощью Bing Maps SDK.

Получение сведений о расположении

Пространство имен Windows.Devices.Geolocation используется для получения сведений о вашем местоположении. На выбор метода определения местоположения пользователя (GPS, Wi-Fi или IP-адрес) влияют два основных фактора:

1. Уровень требуемой точности. Оптимальный уровень точности для вашего приложения.
2. Доступность данных о местоположении. Не во все устройства встроен модуль GPS, кроме того, сеть Wi-Fi может быть недоступна, когда запрашиваются сведения о местоположении.

Требуемая точность

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

• GPS — модуль GPS обеспечивает максимальную точность, погрешность обычно составляет не более 10 метров. Однако если модуль GPS необходимо «разбудить», чтобы получить данные со спутников и провести их триангуляцию, то приложение выдаст сведения о расположении не ранее, чем через 1–2 минуты. Как только модуль GPS установит связь со спутниками, он будет быстрее определять местоположение. Разумеется, чем дольше GPS используется, тем больше энергии потребляет. Чтобы получить данные от модуля GPS, необходимо свойству Geolocator.DesiredAccuracy задать значение High.
• Wi-Fi — соединение Wi-Fi позволяет определять местоположение с точностью до 300–500 метров. При наличии подключения по Wi-Fi, данные о местоположении можно получить быстрее, чем при использовании модуля GPS, которому сначала требуется установить связь со спутниками. Установите для свойства DesiredAccuracy значение Default, если хотите получать сведения о расположении с учетом параметров соединения Wi-Fi.
• IP — IP-адрес позволяет определять местоположение с точностью до 1 км. При наличии сетевого подключения данные о местоположении можно получить быстрее, чем при использовании модуля GPS, которому сначала требуется установить связь со спутниками. Установите также для свойства DesiredAccuracy значение Default, если хотите получать сведения о расположении с учетом IP-адреса. Служба расположений старается вычислить местоположение максимально точно; достигнутая точность указывается в свойстве Geocoordinate.Accuracy.

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

C#

Geolocator geolocator = new Geolocator();
geolocator.DesiredAccuracy = Windows.Devices.Geolocation.PositionAccuracy.High;
 

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

C#

Geoposition pos = await geolocator.GetGeopositionAsync().AsTask(token);

Следующий код JavaScript который создает экземпляр класса Geolocator, задает требуемую точность, а затем получает сведения о текущем местоположении. Обратите внимание на то, что переменная promise представляет собой объект WinJS.Promise, вам понадобиться метод done для получения данных с использованием вызова getGeopositionAsync.

JavaScript

 var geolocator = Windows.Devices.Geolocation.Geolocator();
 geolocator.desiredAccuracy =
 Windows.Devices.Geolocation.PositionAccuracy.high;
 
 // Get the geoposition, capturing the request in a 'promise' object.
 var promise = geolocator.getGeopositionAsync();

Не забывайте о том, что когда вы задаете желаемую точность на уровне High, вы не можете быть уверены в том, что устройство пользователя сможет такую точность обеспечить. На ПК может отсутствовать модуль GPS или он может быть отключен, устройство может быть не подключено к сети Wi-Fi и т. д. Вы всегда должны быть готовы корректно обработать данные с низкой точностью. Как именно вы будете это делать, зависит от функциональных возможностей вашего приложения. Достаточно ли полученные данные точны, чтобы приложение могло продолжить свою работу? Можете ли вы запросить данные с точностью на уровне GPS? Для получения дополнительной информации см. Guidelines for location-aware apps.

Приложение Bing Maps

Bing Maps — хороший пример приложения, которое адаптируется к точности полученных данных о местоположении. На настольном ПК, который обычно не оборудован модулем GPS или Wi-Fi, оно определяет местоположение с учетом IP-адреса, при этом на экран выводится регион, в котором находится пользователь. На ноутбуке со встроенным модулем беспроводной связи приложение использует Wi-Fi, чтобы получить более точные сведения о местоположении и вывести на экран более детализированную информацию. Если пользователь хочет получить еще более точные сведения, то система отображает радиус ошибки. На устройствах, оборудованных модулем GPS, приложение Bing Maps получает максимально точные данные и выводит на экран соответствующие сведения о местоположении.

Приложение Bing Weather

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

Отображение сведений о местоположении с помощью Bing Maps SDK

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

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

C#

Location location = new Location(pos.Coordinate.Latitude, pos.Coordinate.Longitude);

JavaScript:

promise.done(
 function (pos) {
 // Get the coordinates of the current location.
 var coord = pos.coordinate,
 location = new Microsoft.Maps.Location(coord.latitude, coord.longitude);
 
 },
 function (err) {
 // Handle the error.
 });

• Затем местоположение выводится на экран в приложении Bing Maps. Пакет Bing Maps SDK можно загрузить отсюда. Вам также понадобится ключ для Bing Maps. Чтобы его получить, зарегистрируйтесь на портале Bing Maps и следуйте инструкциям: Getting a Bing Maps Key. В процессе регистрации ознакомьтесь с ограничениями для ключа каждого типа и выберите подходящий ключ для своего приложения. 
  Добавьте элемент управления Bing Maps в свой конструктор и укажите ключ в учетных данных.

<Page
 xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
 xmlns:local="using:SimpleMapping"
 xmlns:d="https://schemas.microsoft.com/expression/blend/2008"
 xmlns:mc="https://schemas.openxmlformats.org/markup-compatibility/2006"
 xmlns:Maps="using:Bing.Maps"
 x:Class="SimpleMapping.MainPage"
 mc:Ignorable="d">
 
 <Grid Background="{StaticResource ApplicationPageBackgroundThemeBrush}">
 <Maps:Map x:Name="Map" Margin="0,120,0,0" Credentials="Insert Your Bing Maps Key Here"/>
 </Grid>
 </Page>

• Следующий фрагмент вы можете включить в код страницы в своем приложении, где отображается карта. Здесь настраивается масштаб карты и отображается местоположение. Подробнее о масштабе описано в статье How to display your location on a Bing Map.

C#

double zoomLevel = 13.0f;
 
Map.SetView(location, zoomLevel);

Добавить элемент управления Bing Maps в ваше приложение с использованием JavaScript и HTML немного сложнее. Добавьте следующий тег <script> в код HTML своего приложения:

<script type="text/javascript" 
 src="ms-appx:///Bing.Maps.JavaScript//js/veapicore.js">
 /script>

Затем нужно создать тег <div> с картой и задать атрибут ID, чтобы вы могли получить к нему доступ.

<div id=’map-div’></div>

Наконец, вы должны инициализировать элемент управления карты для своей HTML-страницы. Для этого используется следующий код JavaScript:

// Load the Microsoft.Maps.Map module and then call getMap when the 
 // module has loaded.
 function initMap() {
 Microsoft.Maps.loadModule('Microsoft.Maps.Map', 
 { 
 callback: getMap, 
 culture: "en", 
 homeRegion: "US" 
 });
 }
 
 // Get the div to contain the map from the interface of the app.
 function getMap() {
 
 // Create a new instance of the Map class, passing in the app ID.
 var map = new Microsoft.Maps.Map(
 document.getElementById(mapDivId), 
 { credentials: “Insert your credentials here” });
 
 // Set the initial zoom level and type of map.
 map.setView({
 mapTypeId: Microsoft.Maps.MapTypeId.road,
 zoom: 3
 });
 }

• Кроме того, любое приложение, использующее сведения о расположении, должно учитывать установленные пользователем разрешения, которые могут измениться в любой момент. Приложение Weather использует данные о местоположении, чтобы вывести на экран актуальный прогноз погоды. Но пользователь всегда может зайти в настройки и отключить функцию определения местоположения, и ваше приложение должно учитывать такую возможность. В этом случае приложение Weather должно вывести на экран соответствующее предупреждение, например: «Ваше местоположение не может быть определено. Необходимо разрешить приложению Weather определять ваше местоположение». Рекомендации по поводу работы с пользовательскими настройками при определении местоположения см. в документе Guidelines for location-aware apps (Руководство по разработке приложений, учитывающих географическое положение).  

Функции определения географического положения и использования Bing Maps SDK подробнее рассматриваются в видео, руководствах и примере кода. Там вы найдете пошаговые инструкции для асинхронного получения сведений о расположении с последующей визуализацией этой информации с помощью Bing Maps SDK. Вы узнаете, как активировать функцию определения местоположения, асинхронно получить соответствующие сведения, вывести требуемый участок карты и настроить значок местоположения с учетом точности полученных данных. Дополнительная информация также представлена на странице Bing Maps for Windows Store Apps (Bing Maps и приложения для Магазина Windows).

Упаковка

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

Автор: Росс Хейзе (Ross Heise), старший разработчик контента, Windows Developer Content

Выражаю особую благодарность Джону Кею (Jon Kay) и Эрику Шмидту (Eric Schmidt) за помощь в подготовке этой статьи.

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

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


При работе с функцией whichBranchIsTaken компилятор не знает, как часто параметр «a» будет меньше параметра «b», и сколько раз будет применено условие «if» (т. е. компилятор не может предсказывать ветвления). При работе с функциями девиртуализации и switchCaseExpansion компилятор знает недостаточно о значениях *p и i, что делает невозможным оптимизацию девиртуализации и расширений параметров. Эти проблемы проявятся еще ярче, если мы подставим данный фрагмент кода в разные модули (например, разные объектные файлы), поскольку функции традиционной компиляции не могут быть оптимизированы для работы в пределах исходных модулей.
Базовая модель компилятора и компоновщика не так уж и плоха, но в ней недостает двух основных возможностей для оптимизации. Во-первых, в ней не используется информация, которую можно было бы получить на основе анализа всех исходных файлов (традиционные компиляторы оптимизируют только отдельные объектные файлы). Во-вторых, в ней не проводится оптимизация на базе ожидаемой или профильной реакции приложения. Первый недостаток может быть исправлен с помощью переключателя компилятора (/GL) или переключателя компоновщика (/LTCG), выполняющего полную оптимизацию программы и необходимого для профильной оптимизации приложения. После того, как оптимизация полной программы включена, вы можете применять профильную оптимизацию. Остановимся на ней подробнее.
PGO – это процесс оптимизации компилятора в среде выполнения, применяющий данные профиля, собранные в ходе выполнения важных или требующих высокой производительности пользовательских сценариев, с целью оптимизации приложения. Профильная оптимизация обладает рядом преимуществ по сравнению с традиционной статической оптимизацией, поскольку она принимает в расчет, как будет себя вести приложение в рабочей среде. Благодаря этому оптимизатор может осуществлять оптимизацию по скорости (для частых пользовательских сценариев) или оптимизацию по размеру (для редких сценариев). В результате код становится более лаконичным, что, в конечном счете, повышает производительность приложения.



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

• Первый этап обычно называют фазой инструментирования. В ходе этой фазы идет сборка приложения с заданным набором флагов компиляции. В процессе сборки внутренний компилятор добавляет в созданный код пробные инструкции (зонды), которые используются для записи данных обучения, необходимых на следующем этапе. Всего добавляется три типа зондов (входа в функцию, перехода и значений). Зонд входа в функцию измеряет, как часто запрашивалась та или иная функция. Зонд перехода позволяет узнать, сколько раз была достигнута та или иная ветвь кода. Таким образом в ходе фазы обучения компилятор получает информацию о том, как часто «a > b» в фрагменте кода whichBranchisTaken в заданном сценарии обучения. Зонд значений позволяет получить данные для построения гистограммы значений. Например, зонд значений, добавленный в фрагмент кода switchCaseExpansion, позволит получить данные для построения гистограммы значений для переменной индекса switch case i. Получив в ходе обучения информацию о том, какие значения будет принимать переменная «i», компилятор сможет провести оптимизацию для наиболее частых значений, а также таких функций как switchCaseExpansion. Таким образом, по окончании фазы у нас будет инструментированная версия приложения (с зондами) и пустой файл базы данных (.pgd), в которую будет заноситься информация, полученная в ходе следующей фазы.
• Фаза обучения . В ходе этой фазы пользователь запускает инструментированную версию приложения и проигрывает стандартные пользовательские сценарии, требующие высокой производительности. На выходе мы имеем файлы .pgc, содержащие информацию, связанную с различными пользовательскими сценариями. В процессе обучения информация проходит через зонды, добавленные в ходе первой фазы. На выходе мы получаем pgc-файлы appname!# (где appname соответствует названию приложения, а # — единице плюс числу pgc-файлов appname!# в выходном каталоге построения).
• Последняя фаза PGO — оптимизация. В ходе этой фазы создается оптимизированная версия приложения. Помимо этого, информация из pgc-файлов, полученная в ходе фазы обучения, вносится в фоновом режиме в базу данных (файл .pgd), созданную в ходе инструментирования. Внутренний компилятор затем использует эту базу данных для последующей оптимизации кода и построения еще более совершенной версии приложения.

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

Применение профильной оптимизации

Теперь, когда мы знаем немного больше о профильной оптимизации, рассмотрим ее применение на конкретном примере. Профильную оптимизацию приложения можно осуществлять с помощью Visual Studio или командной строки разработчика. Ниже рассмотрен пример работы в Visual Studio с приложением под условным названием «Nbody Simulation». Если вы хотите узнать больше о PGO в командной строке, обратитесь к этим статьям. Для начала работы загрузите решение в Visual Studio и выберите конфигурацию построения для работы (т.е. «Release»).



Как было упомянуто выше, PGO состоит из трех этапов: инструментирования, обучения и оптимизации. Для создания инструментированной версии приложения, нажмите правой кнопкой мыши по названию проекта («NBodyGravityCPU») и выберите раздел «Instrument» в меню «Profile Guided Optimization».



В Visual Studio будет построена инструментированная версия приложения. После этого можно переходить к фазе обучения. Запустите инструментированную версию приложения. Для этого зайдите в меню «Profile Guided Optimization» и выберите «Run Instrumented/Optimized Application». В нашем случае приложение выполняется с максимально большим телом кода (15360), т. к. будет реализован стабильный пользовательский сценарий, требующий высокой производительности. После того как два основных показателя производительности приложения — FPS (кадров в секунду) и GFlop – примут устойчивые значения, вы можете закрыть приложение. На этом фаза обучения будет завершена, а полученные данные будут сохранены в файле .pgc. По умолчанию файл .pgc будет включен в вашу конфигурацию построения, т.е. каталог «Release». Например, в результате этого обучения создается файл NBodyGravityCPU!1.pgc.



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



В ходе последней фазы PGO создается оптимизированная версия приложения. В меню «Profile Guided Optimization» выберите «Optimize». Будет создана оптимизированная версия приложения. В выходном журнале PGO-построения вы увидите обобщенную информацию о проведенной операции.
Как было сказано выше, информация из файлов .pgc, полученная в ходе фазы обучения, включается в базу данных .pgd, которая затем используется матрицей оптимизации внутреннего компилятора. В большинстве случаев (за исключением небольших быстрых приложений) критерий оптимизации скорость/размер определяется соотношением динамических инструкций для определенной функции. Функции с большим числом инструкций (т. н. «горячие») оптимизируются на скорость, а с малым количеством инструкций (т. н. «холодные») – на размер.
Это практически все, что вам необходимо для того чтобы начать профильную оптимизацию в ваших приложениях. Попробуйте применить PGO для своих приложений и оцените результаты! И обязательно загляните в блог Инструменты для разработчика, возможно вы найдете там еще какие либо интересные решения! 
Автор поста — Анкит Астхана (Ankit Asthana) — руководитель программы по внутреннему компилятору Microsoft Visual С++.