这篇白皮书介绍了如何使用软件工具测试Windows*平台下应用程序的功耗。同时还介绍了如何发现一些影响软件功耗的主要因素。这篇白皮书旨在面向 ISVs, OEMs, 和其他技术相关人士。

经过多年的硬件平台优化，硬件平台功耗逐年降低。CPU有了新的低功耗状态，显示功耗也大幅下降。然而，运行在平台上的软件所产生的功耗问题却越来越明显。在软件方面，多媒体应用程序对功耗的影响更加引人关注。事实上，研究表明优化过的多媒体应用程序播放时间是未优化过的媒体程序的两倍多。这篇白皮书介绍了设计和开发绿色多媒体应用程序需要考虑的要素，以及如何分析和优化多媒体应用软件软件在Intel®平台下的功耗。这篇白皮书旨在面向 ISVs, OEMs, 和其他技术相关人士。

[xhtml]// Additional includes for sensors
#include <InitGuid.h>
#include <SensorsApi.h>
#include <Sensors.h>
// Create a COM interface to the SensorManager object.
ISensorManager* pSensorManager = NULL;
HRESULT hr = ::CoCreateInstance(CLSID_SensorManager, NULL, CLSCTX_INPROC_SERVER, 
    IID_PPV_ARGS(&pSensorManager));
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to CoCreateInstance() the SensorManager."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// Get a collection of all motion sensors on the computer.
ISensorCollection* pSensorCollection = NULL;
hr = pSensorManager->GetSensorsByType(SENSOR_TYPE_GYROMETER_3D, &pSensorCollection);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to find any Gyros on the computer."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]// Additional includes for sensors
#include 
#include 
#include 
// Create a COM interface to the SensorManager object.
ISensorManager* pSensorManager = NULL;
HRESULT hr = ::CoCreateInstance(CLSID_SensorManager, NULL, CLSCTX_INPROC_SERVER, 
    IID_PPV_ARGS(&pSensorManager));
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to CoCreateInstance() the SensorManager."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// Get a collection of all sensors on the computer.
ISensorCollection* pSensorCollection = NULL;
hr = pSensorManager->GetSensorsByCategory(SENSOR_CATEGORY_MOTION, &pSensorCollection);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to find any sensors on the computer."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]// Additional includes for sensors
#include 
#include 
#include 
// Create a COM interface to the SensorManager object.
ISensorManager* pSensorManager = NULL;
HRESULT hr = ::CoCreateInstance(CLSID_SensorManager, NULL, CLSCTX_INPROC_SERVER, 
    IID_PPV_ARGS(&pSensorManager));
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to CoCreateInstance() the SensorManager."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// Get a collection of all 3-axis Gyros on the computer.
ISensorCollection* pSensorCollection = NULL;
hr = pSensorManager->GetSensorsByCategory(SENSOR_CATEGORY_ALL, &pSensorCollection);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to find any Motion sensors on the computer."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]// Hook the SensorManager for any SensorEnter events.
pSensorManagerEventClass = new SensorManagerEventSink();  // create C++ class instance
// get the ISensorManagerEvents COM interface pointer
HRESULT hr = pSensorManagerEventClass->QueryInterface(IID_PPV_ARGS(&pSensorManagerEvents)); 
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot query ISensorManagerEvents interface for our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// hook COM interface of our class to SensorManager eventer
hr = pSensorManager->SetEventSink(pSensorManagerEvents); 
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot SetEventSink on SensorManager to our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]STDMETHODIMP SensorManagerEventSink::OnSensorEnter(ISensor *pSensor, SensorState state)
{
    // Examine the SupportsDataField for SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX.
    VARIANT_BOOL bSupported = VARIANT_FALSE;
    HRESULT hr = pSensor->SupportsDataField(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, &bSupported);
    if (FAILED(hr))
    {
        ::MessageBox(NULL, _T("Cannot check SupportsDataField for SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX."), 
            _T("Sensor C++ Sample"), MB_OK | MB_ICONINFORMATION);
        return hr;
    }
    if (bSupported == VARIANT_FALSE)
    {
        // This is not the sensor we want.
        return -1;
    }
    ISensor *pAls = pSensor;  // It looks like an ALS, memorize it. 
    ::MessageBox(NULL, _T("Ambient Light Sensor has entered."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONINFORMATION);
    .
    .
    .
    return hr;
}
[/xhtml]

[xhtml]// Hook the Sensor for any DataUpdated, Leave, or StateChanged events.
SensorEventSink* pSensorEventClass = new SensorEventSink();  // create C++ class instance
ISensorEvents* pSensorEvents = NULL;
// get the ISensorEvents COM interface pointer
HRESULT hr = pSensorEventClass->QueryInterface(IID_PPV_ARGS(&pSensorEvents)); 
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot query ISensorEvents interface for our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
hr = pSensor->SetEventSink(pSensorEvents); // hook COM interface of our class to Sensor eventer
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot SetEventSink on the Sensor to our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]STDMETHODIMP SensorEventSink::OnLeave(REFSENSOR_ID sensorID)
{
    HRESULT hr = S_OK;
    ::MessageBox(NULL, _T("Ambient Light Sensor has left."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONINFORMATION);
    // Perform any housekeeping tasks for the sensor that is leaving.
    // For example, if you have maintained a reference to the sensor,
    // release it now and set the pointer to NULL.
    return hr;
}
[/xhtml]

[xhtml]ISensor* m_pAls;
ISensor* m_pAccel;
ISensor* m_pTilt;
// Cycle through the collection looking for sensors we care about.
ULONG ulCount = 0;
HRESULT hr = pSensorCollection->GetCount(&ulCount);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to get count of sensors on the computer."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
for (int i = 0; i < (int)ulCount; i++)
{
    hr = pSensorCollection->GetAt(i, &pSensor);
    if (SUCCEEDED(hr))
    {
        VARIANT_BOOL bSupported = VARIANT_FALSE;
        hr = pSensor->SupportsDataField(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, &bSupported);
        if (SUCCEEDED(hr) && (bSupported == VARIANT_TRUE)) m_pAls = pSensor;
        hr = pSensor->SupportsDataField(SENSOR_DATA_TYPE_ACCELERATION_Z_G, &bSupported);
        if (SUCCEEDED(hr) && (bSupported == VARIANT_TRUE)) m_pAccel = pSensor;
        hr = pSensor->SupportsDataField(SENSOR_DATA_TYPE_TILT_Z_DEGREES, &bSupported);
        if (SUCCEEDED(hr) && (bSupported == VARIANT_TRUE)) m_pTilt = pSensor;
        .
        .
        .
    }
}
[/xhtml]

// Configure sensitivity
// create an IPortableDeviceValues container for holding the <Data Field, Sensitivity> tuples.
IPortableDeviceValues* pInSensitivityValues;
hr = ::CoCreateInstance(CLSID_PortableDeviceValues, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pInSensitivityValues));
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to CoCreateInstance() a PortableDeviceValues collection."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// fill in IPortableDeviceValues container contents here: 0.1 G sensitivity in each of X, Y, and Z axes.
PROPVARIANT pv;
PropVariantInit(&pv);
pv.vt = VT_R8; // COM type for (double)
pv.dblVal = (double)0.1;
pInSensitivityValues->SetValue(SENSOR_DATA_TYPE_ACCELERATION_X_G, &pv);
pInSensitivityValues->SetValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, &pv);
pInSensitivityValues->SetValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, &pv);
// create an IPortableDeviceValues container for holding the <SENSOR_PROPERTY_CHANGE_SENSITIVITY, pInSensitivityValues> tuple.
IPortableDeviceValues* pInValues;
hr = ::CoCreateInstance(CLSID_PortableDeviceValues, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pInValues));
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to CoCreateInstance() a PortableDeviceValues collection."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// fill it in
pInValues->SetIPortableDeviceValuesValue(SENSOR_PROPERTY_CHANGE_SENSITIVITY, pInSensitivityValues);
// now actually set the sensitivity
IPortableDeviceValues* pOutValues;
hr = pAls->SetProperties(pInValues, &pOutValues);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to SetProperties() for Sensitivity."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// check to see if any of the setting requests failed
DWORD dwCount = 0;
hr = pOutValues->GetCount(&dwCount);
if (FAILED(hr) || (dwCount > 0))
{
    ::MessageBox(NULL, _T("Failed to set one-or-more Sensitivity values."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
PropVariantClear(&pv);

[xhtml]// Get the sensor's state
SensorState state = SENSOR_STATE_ERROR;
HRESULT hr = pSensor->GetState(&state);
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Unable to get sensor state."), _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
// Check for access permissions, request permission if necessary.
if (state == SENSOR_STATE_ACCESS_DENIED)
{
    // Make a SensorCollection with only the sensors we want to get permission to access.
    ISensorCollection *pSensorCollection = NULL;
    hr = ::CoCreateInstance(CLSID_SensorCollection, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&pSensorCollection));
    if (FAILED(hr))
    {
        ::MessageBox(NULL, _T("Unable to CoCreateInstance() a SensorCollection."), 
            _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
        return -1;
    }
    pSensorCollection->Clear();
    pSensorCollection->Add(pAls); // add 1 or more sensors to request permission for...
    // Have the SensorManager prompt the end-user for permission.
    hr = m_pSensorManager->RequestPermissions(NULL, pSensorCollection, TRUE);
    if (FAILED(hr))
    {
        ::MessageBox(NULL, _T("No permission to access sensors that we care about."), 
            _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
        return -1;
    }
}
[/xhtml]

[xhtml]STDMETHODIMP OnEvent(ISensor *pSensor, REFGUID eventID, IPortableDeviceValues *pEventData);
	STDMETHODIMP OnDataUpdated(ISensor *pSensor, ISensorDataReport *pNewData);
	STDMETHODIMP OnLeave(REFSENSOR_ID sensorID);
	STDMETHODIMP OnStateChanged(ISensor* pSensor, SensorState state);
// Hook the Sensor for any DataUpdated, Leave, or StateChanged events.
SensorEventSink* pSensorEventClass = new SensorEventSink();  // create C++ class instance
ISensorEvents* pSensorEvents = NULL;
// get the ISensorEvents COM interface pointer
HRESULT hr = pSensorEventClass->QueryInterface(IID_PPV_ARGS(&pSensorEvents)); 
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot query ISensorEvents interface for our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
hr = pSensor->SetEventSink(pSensorEvents); // hook COM interface of our class to Sensor eventer
if (FAILED(hr))
{
    ::MessageBox(NULL, _T("Cannot SetEventSink on the Sensor to our callback class."), 
        _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
    return -1;
}
[/xhtml]

[xhtml]STDMETHODIMP SensorEventSink::OnDataUpdated(ISensor *pSensor, ISensorDataReport *pNewData)
{
    HRESULT hr = S_OK;
    if ((NULL == pNewData) || (NULL == pSensor)) return E_INVALIDARG;
    float fLux = 0.0f;
    PROPVARIANT pv = {};
    hr = pNewData->GetSensorValue(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, &pv);
    if (SUCCEEDED(hr))
    {
        if (pv.vt == VT_R4) // make sure the PROPVARIANT holds a float as we expect
        {
            // Get the lux value.
            fLux = pv.fltVal;
            // Update the GUI
            wchar_t *pwszLabelText = (wchar_t *)malloc(64 * sizeof(wchar_t));
            swprintf_s(pwszLabelText, 64, L"Illuminance Lux: %.1f", fLux);
            BOOL bSuccess = ::SetWindowText(m_hwndLabel, (LPCWSTR)pwszLabelText);
            if (bSuccess == FALSE)
            {
                ::MessageBox(NULL, _T("Cannot SetWindowText on label control."), 
                    _T("Sensor C++ Sample"), MB_OK | MB_ICONERROR);
            }
            free(pwszLabelText);
        }
    }
    PropVariantClear(&pv);
    return hr;
}
[/xhtml]

要了解有关编译器优化的更多信息，请参阅优化声明。

超极本™ 的功能可将个人计算提升到全新的水平。 它们的英特尔® 酷睿™ i3-i7 处理器可提供今日移动计算平台都不具备的出色功耗和性能。 超极本具有连接性、游戏、娱乐和环境感知等所有特性。 借助内置触摸屏、传感器和处理器显卡，超极本可为您提供以前不可奢想的多样使用模式。

运行 Windows 8* 的超极本为应用开发人员开启了一个充满无限可能的世界。 无论您是希望编写应用的开发新人，还是希望将应用用于超极本，本文都可为您提供利用 5 种平台特性（让其它特性都黯然失色）所需的资源。

超极本优势

卓越的触摸屏、传感器、显卡、功耗和性能是超极本脱颖而出的主要优势。 每款超极本都有其优势和特性，应用开发人员只有了解它们，才能实现最佳的使用效果。 超极本社区是面向开发人员的一站式社区，他们可在这里找到对开发用于这些设备、性能和体验得到优化的应用极为重要的资源。 从应用设计到软件开发的多个阶段，您可能需要以下部分提供的分类资源，以发挥超极本的优势。

触摸屏和传感器

与传统的输入不同，提供触摸屏应用需要重新构想应用设计，以实现最佳的用户体验。 Windows 8 提供标准的多点触控手势，后者可将新生活融入您的应用中，同时添加自然流畅的交互式元素。

超极本还配置有各种传感器，如 GPS、加速器、方向传感器、倾角计和环境光传感器 (ALS)。 游戏和娱乐应用可使用这些硬件特性，通过富于想象力的用途吸引受众的注意力。 例如，您可根据设备的方向设计一动态用户界面，或通过 ALS 提供环境感知功能以根据周围的光线调暗或调亮显示屏，或使用加速器控制游戏中的导航。 您将需要这部分的资源支持应用中的触摸屏和传感器功能。

触摸屏和传感器资源：
http://software.intel.com/en-us/articles/ultrabook-touch-and-sensors-resources/

功耗

超极本可节省功耗并将电池续航时间延长 6 小时以上。 但是，认为功耗管理只与硬件有关则是一种误导。 在确保超极本高效使用电能方面，软件的作用至关重要。 不能合理使用硬件节电特性的应用，有许多不易被察觉的耗电途径。 这部分介绍了"绿色代码"开发和软件能效标准等概念，提供了可帮助您设计和编写节电应用的工具和资源。

功效和绿色代码开发资源：
http://software.intel.com/en-us/articles/developing-power-efficient-apps-for-ultrabook/

性能

超极本具有出色的性能和移动性。这些设备非常适用于移动式玩游戏、看电影、阅读和浏览社交网络。功耗和性能息息相关，且软件在协调这两者方面可发挥关键的作用。 性能最佳的应用可确保您的设备节电，且拥有更长的电池续航时间。

超极本配置有支持英特尔® 超线程技术的第三代英特尔® 酷睿™ 处理器（代号 Ivy Bridge）。 这种多核架构支持开发人员通过并行编程利用强大的处理能力。 处理器显卡可支持负载平衡和提升性能，同时节省电能。 虽然这种想法看似简单，但设计性能最优的应用需要反复琢磨。 该部分介绍了并行优化等概念及开发多线程应用的指南，并提供了帮助应用开发人员发现和减少性能瓶颈、提高功效的资源和工具。

增强超极本™ 中应用性能的资源：
http://software.intel.com/en-us/articles/performance-enhancement-on-ivy-bridge-ultrabook/

显卡

第二代超极本采用英特尔酷睿处理器。这种微架构包括英特尔® 核心显卡，这意味着 CPU 和 GPU 都位于同一晶片上。 现在，图形和游戏应用可使用该微架构提供的功耗和性能。 与超极本触摸屏和传感器功能结合使用时，游戏和图形应用具有多样的使用模式，而这在以前是不可奢想的。 您可了解到使用 DirectX* 等各种图形管线进行游戏和显卡开发方面的最佳实践，及用于这方面的英特尔酷睿处理器架构和移植技术。 您还可使用所有的英特尔® 工具，它们可帮助您设计和开发充分利用超极本硬件的图形应用。

用于为 Ivy Bridge 超极本™ 开发图形应用的资源：
http://software.intel.com/en-us/articles/developing-graphics-applications-for-ivy-bridge-ultrabook/

借助所有这些资源，您现在可以为超极本开发令其它应用黯然失色的卓越应用！

Intel、英特尔、Ultrabook、超极本、Core、酷睿和 Intel 标识是英特尔在美国和/或其他国家的商标。
英特尔公司 2012 年版权所有。 所有权保留。
*其他的名称和品牌可能是其他所有者的资产。

下载文章

下载第四代智能英特尔® 酷睿™ 处理器核芯显卡参考指南 [PDF 775KB]

客户机显卡亮点

第四代智能英特尔® 酷睿™ 处理器家族中的增强型核芯显卡^1,2

面向主流台式机和笔记本电脑用户的英特尔® 核芯显卡

英特尔® 核芯显卡具备卓越的图像性能，提供更清晰的图像、更丰富的色彩和更逼真的视频与音频。 观看高清晰度的影片和互联网视频，畅玩热门的休闲和主流游戏，同时享受全面的 Microsoft* Windows* 7 和 Windows* 8 支持。无需加插显卡，图形和媒体支持全部内置。 第四代智能英特尔® 酷睿™ 处理器家族中内置增强型英特尔核芯显卡。

英特尔® 快速视频同步

英特尔® 快速视频同步技术支持在家中或在网络上快速制作、编辑、同步和共享视频。 该技术内建于第四代和第三代智能英特尔® 酷睿™ 处理器中，提供突破性的硬件加速功能，可在几分钟内完成过去需要花费几小时的工作。 快速地制作 DVD 或蓝光*光盘、编辑视频、为便携式媒体设备转换视频文件，以及转换并上传视频到喜爱的社交网站。

英特尔® 清晰视频核芯技术

在浏览网页、观看视频及欣赏最喜爱的高清节目时，英特尔® 清晰视频核芯技术可带来流畅的视频、生动的图像以及丰富逼真的色彩。 第四代和第三代智能英特尔® 酷睿™ 处理器中的英特尔清晰视频核芯技术让您以最理想的方式欣赏图像。

英特尔® 无线显示技术

显示器和音频特性对比

连接各种数字显示器，并适用于不同的分辨率，包括 HDMI* 和 DisplayPort* 等最新数字接口。 此外，第四代智能英特尔® 酷睿™ 处理器还支持 720p、1080i 和 1080p 等高清分辨率。

3D 特性比较

英特尔® 酷睿™ 处理器可针对休闲和主流电脑游戏提供极具吸引力的超凡 3D 视觉体验。 购买配置有英特尔^®锐炬™ 显卡或英特尔核芯显卡的电脑，即可获得一款可带来更多游戏乐趣的经济高效的解决方案。

要了解更多信息，请访问 www.intel.cn/content/www/cn/zh/architecture-and-technology/hd-graphics/hd-graphics-developer.html、www.intel.cn/content/www/cn/zh/architecture-and-technology/visual-technology/intel-visual-technology-consumer.html

¹内置核芯显卡仅在某些 SKU 上配置。
²在某些 SKU 上速度更快。
³第四代智能英特尔® 酷睿™ i5-4558U 处理器（28W、2.40 GHz（提速至 2.90 GHz）、2C/4T、英特尔® 锐炬™ 显卡 5100 1.10 GHz、显卡驱动程序： 15.31.3063），相当于第三代智能英特尔® 酷睿™ i3-3687U 处理器（17W、1.90 GHz、2C/4T、英特尔® 核芯显卡 4000 1.10 GHz、显卡驱动程序： 15.28.2875、15.31.3063）
⁴该特色仅限于 U-处理器系列。

性能测试中使用的软件和工作负载可能仅在英特尔微处理器上进行了性能优化。 性能测试（如 SYSmark 和 MobileMark）使用特定的计算机系统、组件、软件、操作系统和功能进行测量。 对这些因素的任何更改可能导致不同的结果。 您应该查询其它信息和性能测试以帮助您对正在考虑的购买作出全面的评估，包括该产品在与其它产品结合使用时的性能。

所有产品和指定日期初步根据当前预期，如有变化恕不另行通知。 不同渠道产品的上市日期可能不同。

英特尔、英特尔标识、Intel Inside、Intel Insider、英特尔酷睿、Core Inside、锐炬和英特尔 InTru 是英特尔公司在美国和其他国家（地区）的商标。

* 文中涉及的其它名称及商标属于各自所有者资产。

商务简报
英特尔® 开发人员专区
英特尔® 凌动™ 处理器 Z3700 系列
Microsoft Windows* 8.1

对 Microsoft Windows 8 的改进以及基于英特尔® 凌动™ 处理器 Z3700 系列的系统芯片（SOC）的引入，为软件开发人员提供了面向创新应用的选项。

计算性平板电脑的迅速普及已重塑了技术的景观。在一份 2013 年第三季度报告中，Parks Associates Research 的分析师 Jennifer Kent 陈述，“在短短三年里，平板电脑已渗透了美国宽带家庭的三分之一，而此类设备设计样式及价格范围的不断扩展，推动着年复一年的增长。"¹

随着这一趋势的继续，许多消费者在寻求能安全地运行他们信赖而熟悉的应用程序、支持他们钟爱的高端游戏、提供下一代视觉体验的高性能平板电脑。面对这些要求，在英特尔® 处理器上运行的 Windows 是用户可以追求的组合。

如图 1 所示，得益于平板电脑设备整体的日益普及，预计至 2016 年，市场对 Windows 平板电脑采用的复合年增长率 (CAGR) 为 42%。²

图 1.趋势：基于 Windows* 的平板电脑。

这一总体的正面展望受到软件开发人员的欢迎，从 Windows 应用程序日益扩展的可获取市场规模 (TAM) 中，他们将大有可为。对 Windows 的开发专长、工具和生态系统支持的广泛组合，揭示了一条赢取市场成功的途径。

基于英特尔® 凌动™ 处理器 Z3700 系列的系统芯片 (SoC) 的引入进一步推进了基于 Windows 的平板电脑的势头。

系统芯片汇集了集成英特尔® 高清显卡、英特尔® 无线显示技术³和 4G LTE 广域网连接性等要素。图像信号处理 (ISP) 2.0 有助于简化对英特尔® 集成性能基元等库函数的调用，使开发人员可腾出手来专攻增值特性的创新。

消费者在 2013 年圣诞节日期间的体验

开发人员正全力以赴创建应用程序，以在即将到来的圣诞节日期间及时交付全新的用户体验。基于下一代英特尔凌动处理器的系统芯片建立在 22nm 制程技术的基础之上，提供前所未有的新一代平板电脑体验，这些体验包括：

• 卓越的性能：对台式机和 Windows 应用商店应用的快速响应性。
• 优异的电池续航时间：能效提高，延长充电间隔。
• 身临其境的视觉效果：加速的高清显卡和视频、英特尔无线显示技术。³
• 多层次安全性：对设备、数据和身份的硬件及软件保护。

要了解关于面向英特尔凌动处理器的 Windows 开发的更多信息，请访问 software.intel.com/windows

¹ Parks Associates, “Tablets: Disrupting Mobile Computing and the Digital Home.” （平板电脑：骚动中的移动计算与数字家园） Jennifer Kent 和 Christopher Coffman，2013 年第三季度。

² Strategy Analytics（战略分析），2013 年。

³要求启用英特尔® 无线显示技术（英特尔® WiDi）的系统、兼容的适配器和电视机。1080p 和蓝牙* 或其它受保护内容回放仅可用于某些基于英特尔® 酷睿™ 处理器的系统，且需启用核芯显卡技术，配备兼容的适配器和媒体播放器，安装支持的英特尔® WiDi 软件和显卡驱动程序。请向您的电脑制造商查询。要了解更多信息，请参阅：www.intel.com/go/widi。

Christopher Phlipot
2013 年 3 月 14 日

下载文章

 Windows DPI Scaling.pdf (336.59 KB)

2013 年，行业开始趋向于在 Windows 设备上采用高分辨率、高 DPI 屏幕。今天，10-11 英寸的平板电脑多数采用 1366x768 分辨率屏幕。然而，您很快会看到同样尺寸的屏幕将采用 1080p 和 1440p 分辨率，因此 DPI 也更高。Microsoft Surface* Pro 平板电脑就是这样一款设备，它使用 1080p 分辨率的10.6 英寸屏幕。Windows 的设计原则是：现有应用可随屏幕分辨率缩放。但是开发人员还需要做一些工作，具体取决于应用类型(桌面或 Windows 应用商店)，从而确保其应用正常缩放。

桌面的 DPI 缩放

Windows 提供多种方法从 Windows 商店应用缩放桌面应用。对于 Windows 桌面，有 4 个缩放级别：100%、125%、150% 和 200%。例如，Microsoft Surface Pro 采用 1080p 10.6 英寸显示屏，默认状态下，桌面可缩放至 150%。

为了充分利用 DPI 缩放，您的应用需要具备 DPI 感知能力。否则，Windows 将自动缩放应用的大小；然而，应用可能显得模糊(见下图 1 )。应用缩放至更高 DPI 以后，为了确保图片和文本依然清晰，最好的办法是确保您的应用具备感知 DPI 的能力。

图 1. 200% 缩放。Internet Explorer* (左侧) 是 DPI 感知的。Chrome* (右侧)不能感知。

为了应用具备感知 DPI 的能力，您必须确保应用的用户界面合理缩放。这需要提供更高分辨率的资产，并确保文本和文本框合理缩放。建议您在高 DPI 场景下测试您的应用。最简单的方法是在控制面板的“显示器设置”中更改显示器缩放设置，如图 2 所示。

图 2.测试桌面应用的 DPI 缩放可在 Windows* 控制面板中更改。

更多信息，请参考微软关于高 DPI 桌面应用的 MSDN 文档：http://msdn.microsoft.com/en-us/library/dd464646.aspx

Windows 商店应用的缩放

Windows 商店应用的缩放方法有所不同。所有应用可自动缩放至合理尺寸。与桌面不同，Windows 8 用户界面支持 100%、140% 和 180% 缩放模式。在高 DPI 的显示屏上，无需开发人员操作，文本、图片以及用户界面中的其余内容均自动缩放至合理尺寸。

然而，使用 140% 和 180% 缩放模式时，为了应用呈现最佳视图，您需要提供更高分辨率的图片。您也可以使用可缩放的矢量图形，在这种情况下，Windows 自动将图片缩放为合理分辨率，同时保留图片质量。

为了应用在不同 DPI 场景下得到合理渲染，建议您使用 Visual Studio* 2012中的模拟器测试您的应用。这时您可以通过更改所模拟的屏幕尺寸和分辨率测试每个 DPI 设置(见图片 3 和 4)。

图 3.在 Windows* 8 环境中，Visual Studio* 2012 中的模拟器可以取消。

图 4.在模拟器右侧的设置中选择不同的屏幕尺寸和分辨率即可更改 DPI。

如需深入了解 Windows 商店应用的显示器缩放，请参考微软 MSDN 文档：http://msdn.microsoft.com/en-us/library/windows/apps/hh465362.aspx

总结

建议您在高 DPI 环境中测试您的应用，确保运行正常、渲染清晰。如需测试桌面应用，您可在控制面板中更改显示器缩放；如需测试 Windows 商店应用，您可使用模拟器。如果您在高 DPI 场景下遇到运行问题，请参考微软 MSDN 文档。

附件

下载 windows-dpi-scaling.pdf (336.59 KB)

介绍

过去几年来，一体式(AIO)电脑已经发展为家庭和办公设备的主流，可交付强大的处理器性能、大屏幕图形功能以及简约而又时尚的外形设计。随着微软推出 Windows* 8，一体式电脑采用了传统键盘与鼠标输入方式以及极具创新特性的触控功能，为最终用户交付新的软硬件交互方式。现在，在上述功能进一步发展的基础上，一款新设备又将产生 — 便携一体式(pAIO)电脑。

便携一体式电脑具备高端技术规格，采用可平放运行的大触控屏，以及可支持有限移动性的内置电池。这些功能有望催生崭新使用场景，同时，整合以下创新特性的应用与游戏有望得以开发：

• 多用户和多触控用户界面
• 基于语音或摄像头采集的手势语的多模式交互
• 多工具场景，例如，使用智能手机作为游戏控制器
• 借助英特尔® 无线显示(WiDi)在高清电视上提供附加游戏或应用视图

能够在水平方向分离运行这一特性为软件开发人员带来了机遇和挑战，他们需要调整思维以利用便携一体式电脑带来的全新特性。本文将介绍可帮助软件开发人员设计此类触控交互应用的四个指南，以及基于英特尔® 处理器的便携一体式(pAIO)电脑的出色用户体验。

指南 1：了解便携一体式电脑的平台功能

便携一体式(pAIO)电脑为应用开发人员带来前所未有的机遇，它具备大触控屏、轻量移动性和平放功能，以及支持多触控、多用户应用的高处理性能 

便携一体式电脑与传统一体式电脑存在一些公共设计元素；然而，基于英特尔处理器的 pAIO 还具备一些关键特性，可为软件开发人员带来新机遇，为最终用户带来新体验。便携一体式电脑支持固定计算和适应性计算体验，提供屏幕倾斜功能，支持垂直、倾斜和平放场景；屏幕尺寸范围是 18.4-27 英寸(图 1)。多触控功能通过触控板提供，支持最低 10 个触控点，轻量移动性通过板载电池提供。通过图片中的轻量移动性和平放功能，pAIO 为开发创新型软件带来了机遇。这些创新型软件可充分利用浸入式大屏幕画布交付的多触控、多用户功能。

图 1.屏幕方向

高度智能的英特尔® 酷睿™ 处理器家族为全特性、多用户、多触控 pAIO 应用交付超高性能和惊艳视觉计算，这些应用涉及的领域包括游戏、教育、娱乐、医疗保健、商业、内容创建和生活方式。应用设计人员可利用英特尔酷睿处理器开发出色应用，交付精彩图片和无缝触控体验(表 1)。

表 1.处理器比较

指南 2：明智选择您的软件开发环境

Windows 8 支持两种不同的开发环境，它们决定着您的开发工具选项、特性可用性、与之前版本 Windows 的兼容性、以及您的发布/销售模式。

Windows 8 支持您使用众多编程语言和工具进行应用开发。您甚至可以使用一种语言编写组件，并用于使用另一种语言编写的应用中。然而，您必须提前决定即将开发的应用类型，是 Windows 商店应用还是 Windows 桌面应用(参见图 2)。

桌面应用可运行于 Windows 8 的 Windows 桌面模式。该模式看似传统 Window 环境，但体验有所不同。桌面模式支持基于触控与传感器的应用。另外，一些硬件驱动程序和设备特性 — 如英特尔® 无线显示技术（英特尔® WiDi）和 OpenGL* 目前仅支持在桌面模式下运行的应用。

Windows 商店应用利用最新 WinRT API，在 Visual Studio* 2012 中使用 C++、C# 或 web 技术而开发，例如 HTML5、JavaScript* 和 CSS3。

图 2.面向 Windows* 8 应用的高级开发环境

开发人员应该知道一些设备特性和技术可能还未面向 Windows 商店应用环境推出或开发。因此，您选择 Windows 商店应用模式还是选择 Windows 桌面应用模式将决定着以下选项：可用的开发环境，可用的硬件特性，与之前版本 Windows 的兼容性，以及应用的销售与发布模式(见表 2)。

向公众发布和销售 Windows 商店应用一般是通过 Windows 商店。Windows 商店向全球庞大客户群发布或出售应用。关于销售和发布应用，桌面开发人员拥有更多选项。除了传统发布和履约选项，一些开发人员可将其桌面应用放在 Windows 商店的列表中(创建一个购买网站的链接)。

表 2.面向 Windows* 商店和 Windows 桌面应用的特性兼容性

指南 3：触控对于开发面向 pAIO 的应用十分关键

Windows 8 支持您针对 Windows 商店应用和 Windows 桌面应用灵活选择

触控为用户提供直观、有趣、自然的应用交互方式。运行于英特尔酷睿处理器架构 pAIO 的多触控多用户应用的用户界面(UI)依赖于在总体设计过程中有机融合并创新运用触控功能。幸运的是，微软已经确保提供密集型触控 API 以支持 Windows 商店应用和桌面应用的开发。  

Windows 商店应用

Windows 为 Windows 商店应用的开发提供两个 API 集合：Windows Runtime (WinRT) 和 Windows Library for JavaScript (WinJS)。

Windows Runtime。这些 JavaScript、C#、Visual Basic* 和 C++ API 可访问所有核心平台特性。

• 使用指针事件获取基本接触信息，例如，位置与设备类型，压力和接触几何等扩展信息，并支持更多复杂交互。
• 使用手势事件管理静态单指操作，例如：点击和按住(双点和右点由基本手势演变)。
• 使用操作事件管理动态多触控操作，夹捏和拉伸以及利用惯性与速率数据的操作，例如，摇拍/滚动、缩放和旋转。

Windows Library for JavaScript。 WinJS 提供 JavaScript API 的库，其中可提供控制、CSS 风格和帮助您编写代码的功能。WinJS 命名空间包含的功能类似于 WinRT 环境中 Windows.UI.XAML 命名空间的功能。

Windows 8 桌面应用

桌面应用运行于 Windows 8 的 Windows 桌面模式。Microsoft Windows 8 桌面应用中支持触控输入和手势的三个方法是：

• WM_POINTER 最容易编码，支持最丰富的手势集，但仅运行于 Windows 8。 WM_POINTER 消息接收触控输入，使用操作语境功能识别来自这些消息的手势。
• WM_GESTURE 编码简单，向后兼容 Windows 7，但是受到的限制也最严格。
• WM_TOUCH 完全向后兼容 Windows 7。每一个触控事件都通知您的应用，您的代码必须采集这些事件并识别其代表的手势。

通常人们错误地认为，不能为桌面模式开发新 Windows 8 基于触控与传感器的应用。这种观点是错误的。另外，一些硬件驱动程序和设备特性 — 如英特尔® 无线显示技术（英特尔® WiDi）和 OpenGL* 目前仅支持在桌面模式下运行的应用。

多模式交互

下一代应用和游戏引入了基于语音与摄像头采集的手势的多模式交互，也有望支持 Windows 8 桌面模式应用。开发人员应当考虑采用英特尔® 感知计算 SDK 以便在 pAIO 上支持多模式交互。另外，开发人员可使用英特尔® 通用连接框架(英特尔® CCF) 以支持多工具场景，例如，智能手机等备用设备可用来控制 pAIO 上运行的游戏。

软件框架与验证

选择开发 Windows 8 桌面游戏的软件设计人员还拥有现有大量软件框架和验证工具的附加优势。这些工具可帮助您在开发 pAIO 应用时加速开发进程、优化性能以及最大程度提高触控响应性能(表 3)。

表 3.Windows* 8 桌面模式软件框架和验证工具

指南 4：了解用户体验

面向多用户多触控水平大屏幕进行设计需要换位思考 — 您面对的不是手机屏幕！

开发人员社区为手机与平板电脑等设备的触控屏设计精彩游戏和应用已经有一段时间了，但是对于 pAIO，小屏幕的限制不复存在，因此，设计人员可整合更多、更出色的交互与控制。

成功的设计需要了解用户通常如何进行应用交互。对于某些应用，一个游戏可同时有四个人玩，因此，从多用户的角度出发十分关键。另外，控制在屏幕上的布局需要切合设备的预期使用模式(表 4)。

表 4.多用户场景示例

用户角度

pAIO 屏幕可拆卸下来平放在桌面上，因此可支持新的多用户应用。对于应用开发人员而言，为多用户设计应用需要了解用户希望如何与应用交互以及用户之间如何交互。了解用户的角度十分关键：

• 早期设计应明确用户的数量和类型。是每个用户都需要一个控制集(很多游戏是这样)，还是所有用户共用一个控制集(多用户协作型应用)
• 最便捷的触控目标是屏幕边缘
• 在特定时间，多个玩家可能有多个关注点

用户控制十分关键

如何设计用户界面影响到触控输入的易用性。为了确保您的应用针对触控而优化，请考虑以下指南：

• 由于 pAIO 屏幕尺寸大，考虑使用大图标和图片 — 需要最低程度的升级
• 每个用户应确信能够通过物理位置、颜色或形状找到可用的控制基于图片的说明通常更易于各方理解
• 触控需要较大的用户界面元素以确保精度，防止手指混淆重要信息。不过，与平板电脑相比，大屏幕的触控为设计人员提供了更多可用空间
• 确保用户界面始终可见，并留意用户的手掌可能接触其它控制或屏幕信息

确保应用生动有趣

可平放在桌面上的大屏幕 pAIO 为设计人员提供了设计精彩、直观、可视化的触控交互机遇。您的应用应具备真实感，吸引用户玩索。以下提示帮助您获得“真实感”：

• 始终为触控交互提供即时、直接的视觉反馈。例如，您可以使用高亮度或工具提示指示当前触控目标，防止无操作其它目标
• 调节物理引擎管理游戏速度。使用加速和惯性等物理效果为摇拍等交互提供自然体验
• 考虑引入下一代功能和多模式交互，例如，基于语音和/或手势的控制

总结

便携一体式电脑具备大屏幕尺寸、轻量移动性和平放功能，为应用开发人员带来新机遇。在英特尔酷睿处理器的支持下，这些创新型应用有望为用户交付出色图片和无缝触控体验。然而，设计这些应用需要换位思考并明确可用的开发选项；而我们英特尔功能提供丰富的资源库，包括软件设计考虑因素、触控集成和平台功能。更多信息，请跟踪以下链接。

设计与开发：

1. 设计面向超极本™ 设备和触控桌面应用：
   http://software.intel.com/en-us/articles/designing-for-ultrabook-devices-and-touch-enabled-desktop-applications
2. 为开发人员开发桌面自然用户界面 API：
   http://software.intel.com/en-us/articles/developing-with-desktop-natural-user-interface-api-s-for-developers
3. 面向 Windows 桌面应用的设计人员工具：
   http://software.intel.com/en-us/articles/designer-tools-for-windows-desktop-applications
4. 为超极本™-触控界面重塑应用：
   http://software.intel.com/en-us/blogs/2012/08/09/re-imagining-apps-for-ultrabook-part-1-touch-interfaces/
5. 触控设计原则：手势和触控目标：
   http://software.intel.com/en-us/blogs/2012/08/29/touch-design-principles-part-2-postures-and-touch-targets
6. 在使用 C# 的 Windows* 8 风格用户界面中支持触控：
   http://software.intel.com/en-us/articles/enabling-touch-in-windows-8-metro-style-apps-with-c
7. 人机触控：在后 PC 时代开发超极本™ 应用：
   http://software.intel.com/en-us/articles/the-human-touch-building-ultrabook-applications-in-a-post-pc-age
8. 在 Windows* 8 应用中处理触控输入：
   http://software.intel.com/en-us/articles/handling-touch-input-in-windows-8-applications
9. 触控友好型控制按钮：
   http://software.intel.com/en-us/articles/touch-friendly-control-buttons-bubbles-2
10. 触控操作示例：
    http://software.intel.com/en-us/articles/touch-reactive-sample-bubbles

代码示例：

1. 比较触控编码技术 – Windows* 8 桌面触控示例：
   http://software.intel.com/en-us/articles/comparing-touch-coding-techniques-windows-8-desktop-touch-sample
2. 触控示例：
   http://software.intel.com/en-us/articles/touch-samples
3. Windows* 8 上超极本™ 桌面应用程序开发：具有触控和感应功能的照片应用程序：
   http://software.intel.com/en-us/articles/photo-application-for-ultrabook-and-windows-8-desktop-applications-development-with-touch-and-sensors
4. Windows 桌面触控摄像头示例：
   http://software.intel.com/en-us/articles/windows-desktop-touch-camera-sample-whitepaper

英特尔公司© 2013 年版权所有。所有权保留。

Intel、英特尔、英特尔标识、AppUp、Core、酷睿、InTru、Ultrabook、超极本是英特尔在美国和/或其他国家的商标。

*其他的名称和品牌可能是其他所有者的资产。

^†OpenCL 和 OpenCL 标识是苹果公司的商标，需获得 Khronos 的许可方能使用。

¹（英特尔® 睿频加速技术）要求系统支持英特尔® 睿频加速技术。仅指定英特尔® 处理器支持英特尔® 睿频加速技术和英特尔® 睿频加速技术 2.0。详情请咨询您的系统生产商。其性能可能因硬件、软件和系统配置的不同而各有所异。更多信息，敬请登陆 www.intel.com/go/turbo。

²（超线程）需要支持英特尔® 超线程（HT）技术的系统；请咨询您的电脑制造商。实际性能会因所使用的具体硬件和软件的不同而有所差异。并非所有英特尔® 处理器都支持该技术。如欲了解更多信息（包括哪些处理器支持英特尔® 超线程技术），请访问 http://www.intel.com/go/ht。

³（英特尔® 快速同步视频-3 年基准）视频转码声称采用 Cyberlink* MediaEspresso 6 来渲染一个时长为 4 分钟、449 MB、1920x1080i、18884 Kbps 的 MPG2 视频文件，在 Apple iPod* 上以 640x360 的分辨率、H.264 和 MP4 文件格式播放。相比英特尔® 酷睿™ 处理器（台式机）和英特尔® 酷睿™ 2 双核处理器 E8400 （台式机）和 P8600 （笔记本），第三代英特尔® 酷睿™ i5-3450 处理器（台式机）和第三代英特尔® 酷睿™ i5-3320M 处理器（笔记本电脑）的速度提升了 4 倍。

⁴（核芯显卡）核芯显卡并不是在所有电脑上都支持，可能需要安装优化软件。请咨询您的系统制造商。更多信息，敬请登录 http://www.intel.com/go/biv。

⁵（英特尔® 无线显示技术）需要配备支持英特尔® 无线显示技术的电脑、平板电脑、智能手机、兼容适配器及电视。敬请注意，1080p 高清功能及蓝光播放功能* 仅限带有内建图形加速功能的指定英特尔® 处理器。请向您的电脑制造商查询。更多信息敬请登陆 www.intel.com/go/widi。

⁶观看立体 3D 内容需要 3D 眼镜和支持 3D 功能的显示器。物理风险系数显示在 3D 材料中。

下载源代码：

PhotoApplication.zip

介绍

众所周知，超极本™ 设备通常具有时尚的美学设计、漂亮的外观和流畅的触控。然而，与大多数标准的笔记本电脑相比，超极本的真正优势就在于它们的硬件性能。除了具备笔记本电脑支持的标准功能外，超极本还具备了一些独有的特性，如触摸屏、GPS、加速计，并支持方向传感器、环境光线传感器、NFC 和其他传感器。当前，消费者在个人计算设备上拥有了更多的选择，比如台式机、笔记本电脑、平板电脑等。大多数的消费者在处理复杂的软件应用和进行数据存储时仍然将台式机或笔记本电脑作为首选。随着智能第三方应用和多任务处理的不断出现，平板电脑以其极高的便携性为我们提供了一个可以替代笔记本电脑的绝佳选择。然而，尽管平板电脑可以处理一些与工作或业务相关的任务，它们仍然无法完全代替笔记本电脑。

而可变形的超极本由于既可以用作平板电脑又可以用作笔记本电脑，因此仅通过自身一台设备即可满足消费者的多重需求。它们不仅具备了笔记本电脑的功能，还具备了平板电脑的易用性和便利性。OEM 厂商在设计可变形超极本时往往能够独出心裁。例如，一些可变形设计可以支持一种可拆卸的键盘，因此在卸下键盘之后显示屏便可以用作独立的平板电脑。而其他的可变形设计则支持显示屏进行滑动或翻转操作，进而可以在平板电脑和笔记本电脑模式间进行切换。

集成 Windows 8 的可变形超极本集两种设备的角色于一身，同时提供了强大的功能。借助集成 Windows 8 的英特尔硬件，用户既可以运行桌面应用，也可以运行 Windows 应用商店（以前称作 Metro-style）中的应用。微软的新 Win RT API 为开发人员提供了在 Windows 8 上创建 Windows 商店应用的工具。另外，一些 Win RT API 还可用于在 Windows 8 上开发桌面应用，这意味着开发人员可轻松将他们的传统 Windows 应用移植至 Windows 8 桌面应用。

以下一系列文章详解了一个简单的超极本图片应用。该应用将展示开发人员如何使用超极本的独有特性（包括触摸屏、GPS、环境光线、方向和电源传感器）来创建出智能、动态的应用。这些代码段和源代码将帮助开发人员将他们的传统 Windows 应用移植到 Windows 8 上。本文同时还说明了如何通过 Windows 8 上的受控代码访问 Win 32 API 上的非受控代码。

面向超极本的图片应用

这是一个简单的 Windows 8 应用，用户可以使用它进行拍照、查看图片、为图片加注地理标记等。该应用支持通过触控和鼠标/键盘输入，为用户提供了极佳的平板电脑和笔记本电脑双模式体验。

以下文章将通过图片应用中的代码段帮助您快速了解超极本设备应用开发的不同方面。第一部分说明了在开发能够支持流畅触控应用时在用户界面设计方面需要注意的事项。此外，你还能学到如何使用一些触摸手势，如“轻拂”、“滑动”、“捏拉”和“缩放”。

为运行 Windows* 8 的超极本™ 增加对桌面应用的触控支持

可实现极佳用户体验的用户界面指南

这一部分文章中将通过代码段帮助你了解功耗感知和环境感知的实施细节，以及如何在你的应用上使用传感器。点击你感兴趣的文章了解更多有关信息：

开发适合搭载 Windows* 8 的超极本TM 的低功耗桌面应用

在搭载 Windows* 8 的超极本的桌面应用中启用加速计传感器

在搭载 Windows* 8 的超极本TM 的桌面应用中启用方向传感器

在搭载 Windows* 8 的超极本TM 的桌面应用中启用环境光线传感器 (ALS)

本应用仅用于说明之目的，尽管如此，我们仍然提供了一个信息板为您展示各种传感器的数据，包括环境光线、方向、功耗等级、亮度等。

相关文章

• Windows 8 超极本传感器开发指南
• 触控：在后 PC 时代开发超极本™ 应用
• 开发适合超极本™ 设备的低功耗应用

通知

本文件中包含关于英特尔产品的信息。本文件不构成对任何知识产权的授权，包括明示的、暗示的，也无论是基于禁止反言的原则或其他。英特尔不承担任何其他责任。英特尔在此作出免责声明：本文件不构成英特尔关于其产品的使用和/或销售的任何明示或暗示的保证，包括不就其产品的(i)对某一特定用途的适用性、(ii)适销性以及(iii)对任何专利、版权或其他知识产权的侵害的承担任何责任或作出任何担保。

除非经过英特尔的书面同意认可，英特尔的产品无意被设计用于或被用于以下应用：即在这样的应用中可因英特尔产品的故障而导致人身伤亡。

英特尔有权随时更改产品的规格和描述而毋需发出通知。设计者不应信赖任何英特产品所不具有的特性，设计者亦不应信赖任何标有保留权利摂或未定义摂说明或特性描述。对此，英特尔保留将来对其进行定义的权利，同时，英特尔不应为因其日后更改该等说明或特性描述而产生的冲突和不相容承担任何责任。此处的信息可随时更改，恕不另行通知。请勿根据本文件提供的信息完成一项产品设计。

本文件所描述的产品可能包含使其与宣称的规格不符的设计缺陷或失误。这些缺陷或失误已收录于勘误表中，可索取获得。

在发出订单之前，请联系当地的英特尔营业部或分销商以获取最新的产品规格。

索取本文件中或英特尔的其他材料中提到、包含订单号的文件的复印件，可拨打 1-800-548-4725 ， 或登陆：http://www.intel.com/design/literature.htm

在性能检测过程中涉及的软件及其性能只有在英特尔微处理器的架构下方能得到优化。诸如SYSmark和MobileMark等测试均系基于特定计算机系统、硬件、软件、操作系统及功能。上述任何要素的变动都有可能导致测试结果的变化。请参考其他信息及性能测试（包括结合其他产品使用时的运行性能）以对目标产品进行全面评估。

对本文件中包含的软件源代码的提供均依据相关软件许可而做出，任何对该等源代码的使用和复制均应按照相关软件许可的条款执行。

英特尔、超极本和 Intel 标识是英特尔在美国和/或其他国家的商标。

英特尔公司 2012 年版权所有。所有权利受到保护。

*其他的名称和品牌可能是其他所有者的资产。

附件

下载 photoapplication.zip (19.26 MB)

下载 PDF›

随着 Windows 8* 以及支持触控的计算机的推出（例如英特尔超极本™ 设备，其中触摸是额外的输入方式），用户拥有了与应用和软件交互的新方式。在过去，触摸仅限制在特殊设备中使用，这些设备需要专门的软件，而今天我们看到大量制造商正在制造支持这些新输入方式的设备。

超极本在这些设备中显得卓尔不同，不仅包含触摸功能，也配备有笔记本电脑式键盘和鼠标触控板，以便于以传统方式操作。因此用户可选择过去所用的键盘，也可使用触摸作为输入源。

The 智能手机和平板电脑的广泛普及意味着设计人员需要调整自己的思维，清楚了解触摸的功能和限制。本文将讨论这对用户界面的设计有何影响，并提供一些指导以设计出可促进交互并提供卓越用户体验的出色软件。

触摸

触摸输入并非全新的输入方式。这种方式实际上已存在了很长时间（我参与开发的首个基于触摸的应用程序可追溯到 90 年代早期），但是直到最近才走向平价，在主流设备中获得广泛应用。在过去，构建基于触摸的应用程序的情况非常少见，而今天的智能手机几乎都以触摸为基础，并且最终用户也十分喜爱这种方式。随着全新 Windows 8 （设计定位为触摸优先系统）的发布，预期将有更多设备采用触摸模式，无论是平板电脑、台式机还是笔记本电脑。

用户应当能以自然的方式与超极本的触摸屏交互。如果屏幕上有按钮，它们应该凸显出来，在触碰它后，发生的效果就和将鼠标移动到按钮上并进行点击一样。相似地，诸如二指拨动缩放以及触摸并拖动以将内容在屏幕上四处平移的手势应当能如用户所预期一般发挥作用。

触摸方式是全特性设备在功能上的绝佳补充。

是否可触控

用户不仅仅会处于支持触控的情况，在某些情况下，例如设备的键盘被隐藏或移除，就可能处于只能进行触控的环境。如果应用程序依赖于鼠标行为（例如悬停以展示命令或操作），用户将无法使用软件。为了让这种软件可用，我们必须确保控件足够大以支持触控，并且在预期的使用模式下布置方式将会有效。

触摸设计包括确定投入多少时间和资源更合适，这需要根据对于业务的重要性以及投资回报 (ROI) 进行权衡。例如，投入到面向客户的应用程序上可能要比投入到仅有少数用户使用的内部应用程序上得到更高的投资回报（业务关键应用程序可能并非如此）。

定义了数个支持触控的应用程序类别。这些类别包括：

• 可触控：控件的尺寸被设计得足够大以在只能触控的环境下正确发挥作用，据研究表明，尺寸至少要达到 23 x 23 (6 mm) 像素并且控件之间要有足够的空间，才能防止意外误操作。应用程序能够感知和使用诸如轻拂和平移的手势，从而移动可滚动的区域并且无需使用悬停。
• 触控支持：大多数常用控件至少达到 40x40 像素 (10 mm)，并且支持触控目标的标准相关手势，例如平移、二指拨动缩放和旋转。基本多点触摸操作已实施，并且能够如预期发挥作用。
• 触控优化：重新访问内容以最大程度降低混乱并尽可能提升用户体验。使用战略性布置在屏幕上易于访问的区域中的控件执行任务。诸如惯量和动量的更高级别的交互功能可让界面变得更生动。

将现有应用程序迁移到新环境的挑战在于至少确保这些应用程序可触控，从而能够在只能触控的环境下起作用。为了帮助您进行投入决策，本文将讨论重新设计触摸操作系统时用到的一些设计原则，并探索如何将它们应用至桌面。

触控设计原则

在 2011 年的 Build conference 大会上亮相的 Windows 8 的设计人员们讨论了他们用于开发以触控优先的框架的一套原则。这些原则包括：

触控应当自然而直观。通过用户触碰屏幕来获取触摸输入，从而选择和操作对象和控件。这意味着最终用户不需要专门的培训就可与应用程序交互。例如在使用超极本时，其中一个很好的功能是可以创建并使用触摸密码来登录。与其他一些身份验证模式相比，这样不仅更个性化，速度也更快，并且更安全。

直接而真实。 触摸一个控件可操作该控件，而不是操作界面中不同区域中的对象，并且对用户提供发生了某些事件的反馈。这种反馈包括声音或振动。包括惯量和动量等特性可提供更为实际的体验，并且与真实世界更为一致。

例如在屏幕上用手指轻拂某个控件可移动图片，但是在摩擦力和惯量的作用下最终停下来。如果尝试做一些不支持的操作，例如将控件移动至屏幕上无效的位置，它会轻微移动，但是会迅速返回原位置。

可移植并且一致。应用程序应当遵照行业标准并且以一致的方式实施手势。手势和操作在不同应用程序上意味着同样的事情。例如，二指拨动手势可通过将控件调整得更小来缩小或影响控件，而分开手指的手势则起到相反的作用。触摸和拖放可执行平移操作。在创建新的自定义手势时需要仔细思考，尤其是在和系统手势的操作方式一样时。

没有阻碍。 设计为可感知触摸的控件要容易访问并且在界面设计中位于合理的位置。对这些对象的操作不会妨碍或阻碍任务的完成。

触摸限制

触摸在选择上的精确度较差，并且不可执行应用程序的悬停等事件。因此设计人员需要确保控件足够大，要有足够的边距，以便能触摸到它们。不应该加入依靠悬停（类似鼠标悬停）来完成操作或任务的控件。应当了解的一些限制包括：

• 鼠标和指针具有很高的精度，可让用户选择特定像素，而触摸的精度要差得多，需要触摸目标足够大并且目标间隔足够距离才能选择目标。例如在使用触摸在屏幕上书写时，您无法看到接触点在何处。用于文本输入的其他方式可能更有效。

• 屏幕上尺寸更大的控件以及可选键盘显示意味着可供显示内容的屏幕区域变小。
• 既然悬停不可用，则将需要重新构思依赖于悬停的控件。
• 用于文本、输入和选择时将更为困难。
• 屏幕键盘会占用空间，从而留给您的内容的空间变少。

• 触摸必须是可以撤销的，有时用户会不小心碰到屏幕并触摸到一些东西，应用不应该进行不可恢复的破坏性行为。

采用触摸通常是为了以易用和自然的方式与应用程序交互，它可能是众多输入方式中的一种，也可能是唯一可用的输入方式。这意味着您的应用程序不能依赖于键盘和鼠标的可用性。由于触摸和手势活动由操作系统转变为鼠标事件，因而良好支持鼠标的应用程序可方便地转变为支持触控的应用程序。

触摸目标大小调整考虑事项

将触摸作为输入方式时，首先要考虑的事项之一是用于选取操作的物体，也就是手指，要比鼠标指针或触摸笔尖大得多。手指的大小可从儿童的 8 mm 到职业运动员的 18 mm 或更大。平均大小在 11 mm 到 15 mm 之间。

指导

触摸目标要有足够的大小才能实现可触控，至少要达到 23 x 23 像素（大约 6 mm）。有些控件则过小而无法触摸到，例如大小为 9 x 15 像素的旋转控件，因此设计人员应当考虑备选方式，为用户提供更多选择。

控件之间的间隔是另一方面，越大越好。如果链接或选项彼此过于靠近，用户则更有可能发生误触。因此，如果空间允许，建议增大控件之间的间距。

工具栏图标为默认大小（16 x 16 像素）时难以被触摸到，因此您应当考虑使用更大的图标，并且在其间加入足够大的边距，让进行所需的选择更为容易。五个像素大小的边距比较合适，但是如果屏幕布局允许，则越大越好。此外要考虑包含在工具栏中的控件的类型，例如下拉列表或文本框，并让它们足够大，以正常发挥作用。

菜单区域中，命令之间的间隔可能对于只能触控的设备显得过于紧凑。默认设置下，命令之间的间隔为 7 个像素，但是如果多增加 4 个像素，就可以拥有更加易用的菜单系统。幸运的是，您可利用操作系统的原生功能帮助您实现体验的一致性和实施应用程序所需的大量工作。

如果这些准则显得过于约束，可考虑使用功能区。该控件于 2007 年推出，采用触摸友好型设计，允许您选择按钮大小和组织方式，以满足非常复杂的场景的要求。例如，Windows Explorer 使用标准的功能区让查找用于文件复制或重命名的命令更为容易，还以直观、易用的方式提供了对于非常用命令的访问。请注意，最常用的命令将以更大的图标表示。

功能区也是可折叠的。因此在不需要它时，用户可在视图中隐藏它。按钮、复选框、组合框以及其他命令可设计到功能区中，让用户可更方便地根据需要查找和完成任务。

位置 – 控件的布置

一般而言，开发人员可以根据硬件限制来限制应用程序必须感知的布局数目。具有 1024 x 768 屏幕大小的标准横向意味着应用程序设计人员可以直接在画布上安排控件，并且应用对大多数用户可用。由于平板电脑和超极本可以方便地旋转，控件的固定布局意味着屏幕的特定区域将比其他区域更容易被触摸到。在平板电脑上效果良好的控件布局可能在笔记本电脑上适得其反。

这种情况下，自适应的布局将凸显作用。使用诸如 XAML 的标记语言构建的应用程序可使用布局容器来放置控件，并让它们更接近用户。通过检测输入设备（例如物理键盘的可用性）来确定哪种布局适用，这样将帮助您的应用程序适应正在使用的设备。确保常用控件之间有明显的差异是不错的做法，无论是位置还是所用的图像都最好有明显差异。例如，您不希望用户在需要点击保存时意外碰到删除或取消。

多个布局的设计

设计人员需要确保软件将会适应用户选择将在其中运行它的环境。这意味着我们需要测试一个分辨率矩阵，确保软件良好工作，其中包括根据每种可能采用的输入方式测试每种分辨率。

这样会增加要测试的场景数目。但是通过了解不同的操作模式，您将了解自己的软件是否可满足用户期望的使用方式。

系统控件和手势

关于 Windows 8 要注意的一点是，屏幕的边距由操作系统用作访问特定功能和行为的常用位置。例如，从屏幕右侧轻扫将显示超级按钮。从左侧轻扫将允许用户循环访问活动的应用程序栈。在放置控件时，您应当避免与该区域过于接近，从而与这些系统手势混淆。

• 超级按钮 –从屏幕的左缘轻扫便可显示 Windows 8 支持的标准功能，其中包括搜索、共享、开始、设备和设置
• 应用程序栈 –从屏幕的右缘轻扫，就可在活动的应用程序之间切换。向内和向外轻扫可显示活动的应用程序的缩略图。
• 应用程序栏 –从顶部或底部轻扫可显示应用程序栏，其中有上下文与活动的应用程序一致的命令，但在桌面模式中，由于桌面处于活动状态而没有活动的应用程序栏。

灵敏响应

在实施某个行为时，您应当确保应用程序立即响应。如果在与应用程序交互时延迟过长，将导致用户怀疑应用程序是否理解手势或操作。请记住，触控应当直接而简便。因此当实施某个行为时，如果可行，可尝试将复杂处理卸载到后台进行。

对于复杂的动画，建议在这些动画需要大量时间和/或处理时，以单独的线程运行它们您也可在动画的末尾完成细节渲染。

考虑内容空间

很显然，如果我们需要更大的控件尺寸以及控件之间的更大边距，就无法在单个屏幕上放置足够多的内容。就强制我们了解特定交互点的核心数据是什么而言，这并不一定是坏事。通过去除不重要的细节或将它们移动至其他屏幕并提供在它们之间顺畅导航的方法而确保屏幕的整洁有序，这样可提高应用程序的易用性。

简单是好事。挑战在于确定要点以专注于应用的本旨。确定在不同点用户需要在屏幕上呈现什么将有助于划分内容优先级。有时候当前选择的控件的上下文有助于确定在不同时刻应当显示和隐藏什么。

总结

尽管大多数 Windows 7 应用程序确实可继续在 Windows 8 上运行，但这并不意味着应用程序能够全面发挥自己的功能。如果在只能触控的设备中使用依赖于悬停或准确到像素的指点和选择操作，则对设计以及触摸的整合的构思将显得很关键。

没有完全一样的应用程序，但是您应当谨慎确定投入多少更合适。至少，要使用足够大的控件以支持只能触控的环境，让应用程序可触控。把握好控件的大小、间隔和布置方面的触摸原则，确保界面的干净整洁。

最后要注意的一点是，触摸虽然体验甚佳，但在超极本上它是键盘和鼠标之外的额外输入方式。有句格言说得好，“可以这样做并不意味着你应当这样做”，因此您应该将触摸用在最合适的地方，并发挥其他输入方式的优势。在设计应用程序时，外观以及使用模式将影响您内容的安排方式，对此有相应的数个视频和文章专门讨论了已做的相关研究（请参见下面提供的参考资料）。

支持触控的超极本是一种极佳的设备，将改变人们使用笔记本电脑的方式。马上开始利用新功能并探索构建支持触控的应用程序的方法吧。

参考

撰写本文所用的资源如下：

• 有关 Daria Loi 对触控的研究的文章 - http://www.intelfreepress.com/news/do-people-want-touch-on-laptop-screens/
• Steve Chippy Paine 的有关超极本触摸屏使用方法示例的视频 - http://www.youtube.com/watch?v=WIm2w2oNdA8&feature=relmfu
• Windows 触控指南 - http://msdn.microsoft.com/en-us/library/windows/desktop/cc872774.aspx
• 设计自适应网站 - http://msdn.microsoft.com/library/ie/jj583806.aspx
• Luke Wroblewski 的有关重新构思超极本应用的视频 - http://software.intel.com/en-us/videos/re-imagining-apps-for-ultrabook-part-1-touch-interfaces
• 了解 Windows 触控 - http://msdn.microsoft.com/en-us/library/windows/desktop/touch.aspx
• 构建 Windows 8 博客 - http://blogs.msdn.com/b/b8/archive/2012/03/28/touch-hardware-and-windows-8.aspx
• 使用图片密码登录 - http://blogs.msdn.com/b/b8/archive/2011/12/16/signing-in-with-a-picture-password.aspx

附件

下载 design-for-desktop-touch-and-the-ultrabook-ccefinal.pdf (890.92 KB)

One of the best known C++ threading libraries Intel® Threading Building Blocks (Intel® TBB) was recently updated to a new release 4.2. The updated version contains several key new features comparing to previous release 4.1. Some of them were already released in TBB 4.1 updates.

New synchronization primitive speculative_spin_mutex introduces support for speculative locking. This has become possible using Intel(R) Transactional Synchronization Extensions (Intel® TSX) hardware feature available in 4th generation Intel® Core™ processors. On processors that support hardware transactional memory (like Intel® TSX) speculative mutexes work by letting multiple threads acquire the same lock, as long as there are no "conflicts" that may generate different results than non-speculative locking. So no serialization happens in non-contended cases. This may significantly improve performance and scalability for “short” critical sections. If there is no hardware support for transactional synchronization, speculative mutexes behave like their non-speculating counterparts, but possibly with worse performance.

Intel TBB now supports exact exception propagation feature (based on C++11 exception_ptr). With exception_ptr, exception objects can be safely copied between threads. This brings flexibility in exception handling in multithreaded environment. Now exact exception propagation is available in prebuilt binaries for all platforms: OS X*, Windows* and Linux*. On OS X* there are two sets of binaries: first is linked with gcc standard library – it used by default and doesn’t support exact exception propagation. To use the feature you should take the second set of binaries linked with libc++, the C++ standard library in Clang. To use these, set up the Intel TBB environment and build your application in the following way:

# tbbvars.sh libc++

# clang++ -stdlib=libc++ -std=c++11 concurrent_code.cpp -ltbb

In addition to concurrent_unordered_set and concurrent_unordered_map containers, we now porvide concurrent_unordered_multiset and concurrent_unordered_multimap based on Microsoft* PPL prototype.  concurrent_unordered_multiset provides ability to insert an item more than once, that is not possible in  concurrent_unordered_set. Similarly, concurrent_unordered_multimap allows to insert more than one <key,value> pair with the same key value. For the both “multi” containersfindwill return the first item (or <key,value> pair ) in the table with a matching search key.

Intel TBB containers can now be conveniently initialized with value lists as specified by C++ 11 (initializer lists):

tbb::concurrent_vector<int> v ({1,2,3,4,5} );

Currently initialize lists are supported by the following containers:

concurrent_vector
concurrent_hash_map
concurrent_unordered_set
concurrent_unordered_multiset
concurrent_unordered_map
concurrent_unordered_multimap
concurrent_priority_queue

Scalable memory allocator has caches for allocated memory in each thread. This is done for sake of performance, but often at the cost of increased memory usage. Although the memory allocator tries hard to avoid excessive memory usage, for complex cases Intel TBB 4.2 gives more control to the programmer: it is now possible to reduce memory consumption by cleaning thread caches with scalable_allocation_command() function. There were also made several improvements in overall allocator performance.

Intel TBB library is widely used on different platforms. Mobile developers can now find prebuilt binary files for Android in the Linux* OS package. Binary files for Windows Store* applications were added to the Windows* OS package.

Atomic variables tbb::atomic<T> now have constructors when used in C++11. This allows programmer to value-initialize them on declaration, with const expressions properly supported. Currently this works for gcc and Clang compilers:

tbb::atomic<int> v=5;

The new community preview feature allows waiting until all worker threads terminate. This may be needed if applications forks processes, or TBB dynamic library can be unloaded in runtime (e.g. if TBB is a part of a plugin). To enable waiting for workers initialize task_scheduler_init object this way:

#define TBB_PREVIEW_WAITING_FOR_WORKERS 1
tbb::task_scheduler_init scheduler_obj (threads, 0, /*wait_workers=*/true);

Find the new TBB 4.2 from commercial and open source sites. Download and enjoy the new functionality!

by Egor Churaev

Downloads

Intel® HTML5 Tools for developing mobile applications [PDF 821.98KB]
iOS Source Code[ZIP file 168 KB]
HTML5 Tools Result Source Code[ZIP file 86KB]

HTML5 is the new HTML standard. Recently, Intel Corporation announced a set of HTML5 Tools for developing mobile applications. This paper shows you how to port an Apple iOS* accelerometer app to HTML5 using these tools. Please note: Auto-generated code created by the XDK may contain code licensed under one or more of the licenses detailed in Appendix A of this document.  Please refer to the XDK output for details on which libraries are used to enable your application.

Intel® HTML5 App Porter Tool

The first thing we’ll do is take an iOS accelerometer app and convert the Objective-C*source code to HTML5. We’ll do this using the Intel® HTML5 App Porter Tool and the source code found here: [iOS_source.zip] (Note: IOS_source sample code is provided under the Intel Sample Software License detailed in Appendix B).You can download the Intel HTML5 App Porter Tool from the Tools tab here:  http://software.intel.com/en-us/html5. After filling in and submitting the form with your e-mail address, you will get links for downloading this tool. The instructions for how to use this tool can be found on this site http://software.intel.com/en-us/articles/tutorial-creating-an-html5-app-from-a-native-ios-project-with-intel-html5-app-porter-tool.

When you are finished performing all the steps, you will get HTML5 source code.

Intel® XDK

You can open the HTML5 code in any IDE. Intel offers you a convenient tool for developing HTML5 applications: Intel® XDK – Cross platform development kit (http://html5dev-software.intel.com/). With Intel XDK, developers can write a single source code for deployment on many devices. What is particularly good is it is not necessary to install it on your computer. You can install it as an extension for Google Chrome*. If you use another browser, you have to download a JavaScript* file and run it. Sometimes it’s necessary to update Java*.

After installing Intel XDK, you will see the main window:

If you want to port existing code, press the big “Start new” button.

If you’re creating a new project, enter the Project Name and check “Create your own from scratch,” as shown in the screen shot below.

Check “Use a blank project.” Wait a bit, and you will see the message “Application Created Successfully!”

Click “Open project folder.”

Remove all files from this folder and copy the ported files. We haven’t quite ported the accelerometer app yet. We still have to write an interface for it. It is possible to remove the hooks created by the Intel HTML5 App Porter tool. Remove these files:

• todo_api_application__uiaccelerometerdelegate.js
• todo_api_application_uiacceleration.js
• todo_api_application_uiaccelerometer.js
• todo_api_js_c_global.js

To update the project in Intel XDK, go to the editor window in the Windows emulator.

Open the index.html file and remove the lines left from the included files.

Open the todo_api_application_appdelegate.js fileand implement the unmapped “window” property of the delegate.

application.AppDelegate.prototype.setWindow = function(arg1) {
    // ================================================================
    // REFERENCES TO THIS FUNCTION:
    // line(17): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: [*js.APT.View]
    //    Expected return type: [unknown type]
    //
    //if (APT.Global.THROW_IF_NOT_IMPLEMENTED)
    //{
        // TODO remove exception handling when implementing this method
       // throw "Not implemented function: application.AppDelegate.setWindow";
    //}
this._window = arg1;
};

application.AppDelegate.prototype.window = function() {
    // ================================================================
    // REFERENCES TO THIS FUNCTION:
    // line(20): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: none
    //    Expected return type: [unknown type]
    //
    // line(21): C:WorkBloggingechuraevAccelerometerAccelerometerAppDelegate.m
    //    In scope: AppDelegate.application_didFinishLaunchingWithOptions
    //    Actual arguments types: none
    //    Expected return type: [unknown type]
    //
    //if (APT.Global.THROW_IF_NOT_IMPLEMENTED)
    //{
        // TODO remove exception handling when implementing this method
       // throw "Not implemented function: application.AppDelegate.window";
    //}
return this._window;
};

Open the viewcontroller.js file. Remove all the functions used for working with the accelerometer in the old iOS app. In the end we get this file:

APT.createNamespace("application");

document.addEventListener("appMobi.device.ready",onDeviceReady,false);

APT.ViewController = Class.$define("APT.ViewController");

application.ViewController = Class.$define("application.ViewController", APT.ViewController, {
    __init__: function() {
        this.$super();
    };>});

div#Label_590244915
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 320px;
	top: 0px;
	opacity: 1;
}
div#Label_781338720
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 29px;
	opacity: 1;
}
div#Label_463949782
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 51px;
	opacity: 1;
}
div#Label_817497855
{
	left: 20px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 74px;
	opacity: 1;
}
div#Label_705687206
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 29px;
	opacity: 1;
}
div#Label_782673145
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 51px;
	opacity: 1;
}
div#Label_1067317462
{
	left: 70px;
	color: rgba(256,256,256,1);
	height: 21px;
	position: absolute;
	text-align: left;
	width: 42px;
	top: 74px;
	opacity: 1;
}
div#View_774585933
{
	left: 0px;
	height: 548px;
	position: absolute;
	width: 320px;
	top: 20px;
	opacity: 1;
}

After updating the emulator window, you see:

To code the accelerometer functions, we need to use the appMobi JavaScript Library. Documentation for this library can be found here. It’s installed when you download Intel XDK.

Open the index.html file and add this line into the list of scripts:

<script type="text/javascript" charset="utf-8" src="http://localhost:58888/_appMobi/appmobi.js"></script>

Open the ViewController_View_774585933.html file. We have to rename fields to more logical names from:

<div data-apt-class="Label" id="Label_705687206">0</div>
<div data-apt-class="Label" id="Label_782673145">0</div>
<div data-apt-class="Label" id="Label_1067317462">0</div>

to:

<div data-apt-class="Label" id="accel_x">0</div>
<div data-apt-class="Label" id="accel_y">0</div>
<div data-apt-class="Label" id="accel_z">0</div>

The same should be done in the ViewController_View_774585933.css file, where we have to rename the style names.

Open the viewcontroller.js file and write some functions for using the accelerometer.

function suc(a) {
    document.getElementById('accel_x').innerHTML = a.x;
    document.getElementById('accel_y').innerHTML = a.y;
    document.getElementById('accel_z').innerHTML = a.z;
}

var watchAccel = function () {
    var opt = {};
    opt.frequency = 5;
    timer = AppMobi.accelerometer.watchAcceleration(suc, opt);
}

function onDeviceReady() {
    watchAccel();
}
document.addEventListener("appMobi.device.ready",onDeviceReady,false);

Update the project, and you can see it on the emulator window:

You can see how the accelerometer works on Intel XDK using the “ACCELEROMETER” panel:

The application will look like this:

The complete application source code can be found here.
Appendix A: Intel ®XDK Code License Agreements

Appendix B: Intel Sample Source Code License Agreement

Intel and the Intel logo are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.

下载视频

1280X720 (89.49 MB)

IdentityMine 公司的 Evan Lang 介绍基于一体机开发的空中曲棍球游戏，包括对便携式一体机所需的应用开发流程所做的特殊更改。

下载

下载第四代英特尔酷睿处理器简介（代号：Haswell） PDF [614KB]

摘要

英特尔推出第四代英特尔® 酷睿™处理器，代号为 Haswell。 其功能基于第三代英特尔® 酷睿™ 处理器显卡。 该篇文章概括介绍了第四代处理器，并突出介绍了英特尔® 锐炬™ 显卡、性能增强功能、低功耗选项、面部识别功能等。 此外，Microsoft Windows* 8 开发人员还可了解桌面和 Modern UI 环境中可用的功能，以及如何利用第四代处理器的功能。

主要的第^四代处理器特性

新处理器基于在第二代英特尔® 酷睿™ 处理器中首次推出的处理器显卡架构。 虽然它们采用了 32 纳米制程而构建，但是第三代和第四代处理器均基于 22 纳米技术。 下列参数描述了第三代和第四代处理器之间的差别。

面向电脑的首款片上系统 (SoC)

第四代英特尔® 酷睿™ 处理器是首款面向电脑的 SoC。 片上系统（SoC）将一个系统所需的所有主要构造模块集成到一个芯片上。 该创新模块设计集 CPU、显卡、内存和连接性于一体，能够将强大的处理器显卡解决方案融入多种外形。

更长的电池续航时间

第四代处理器可播放长达 9.1 小时的高清视频，而第三代处理器仅可播放 6 小时。 此外，最新一代处理器支持长达 10-13 天的待机时间（包括更新电子邮件和社交媒体通知），而第三代处理器仅支持 4.5 天。

表 1： 第三代和第四代英特尔® 酷睿™ 处理器的电池续航时间比较。

[在性能检测过程中涉及的软件及其性能只有在英特尔微处理器的架构下方能得到优化。 诸如 SYSmark* 和 MobileMark* 等性能测试均系基于特定计算机系统、组件、软件、操作及功能。 上述任何要素的变动都有可能导致测试结果的变化。 请参考其他信息及性能测试（包括结合其他产品使用时的运行性能）以对目标产品进行全面评估。 配置⁽ⁱ⁾。 如欲了解更多信息，请访问：http://www.intel.com/performance.]

注： 热设计功耗（TDP）代表负荷最重时的系统功耗。

英特尔® 锐炬™ 显卡

英特尔锐炬显卡支持您播放图形最密集的游戏，而无需使用其他显卡。 第四代处理器上的显卡性能为上一代英特尔® 核芯显卡的近 2 倍。

图 1： 第^四代英特尔酷睿处理器与上一代产品的显卡性能比较

[在性能检测过程中涉及的软件及其性能只有在英特尔微处理器的架构下方能得到优化。 诸如 SYSmark* 和 MobileMark* 等性能测试均系基于特定计算机系统、组件、软件、操作及功能。 上述任何要素的变动都有可能导致测试结果的变化。 请参考其他信息及性能测试（包括结合其他产品使用时的运行性能）以对目标产品进行全面评估。 配置⁽ⁱⁱ⁾。 如欲了解更多信息，请访问：http://www.intel.com/performance.]

此外，采用内置 eDRAM 的英特尔锐炬 Pro 显卡提供的性能是超极本? 设备上第三代核芯显卡 GPU 的近 2 倍。 两种 GPU 均可在高于 28W 的热设计功耗（TDP）下运行，而第三代显卡仅支持 17W TDP，这使得前者更适合台式机/一体机/笔记本电脑上的高性能操作[来源： http://arstechnica.com/gadgets/2013/05/intels-iris-wants-to-change-how-you-feel-about-integrated-graphics/]

此外，英特尔锐炬显卡还支持 Direct3D* 11.1、OpenGL* 4.1 和 OpenCL* 1.2、英特尔快速同步视频编码引擎、Intel® AVX 2.0 和 DirectX 扩展。

4^第四代英特尔® 酷睿™ 处理器不同版本

英特尔提供了多种第四代处理器包装，以满足日益增多的系统类型： 工作站、台式机、超极本系统、一体机、笔记本电脑和平板电脑。 虽然针对工作站和台式机的高端版本可提供更高的性能，但是它们也比更节能的移动版本能耗更高。 下表 2 对适用于不同外形和用途的版本进行了比较。

表 2： 4^第四代英特尔® 酷睿™ 处理器不同版本

U 和 Y 系列专为超极本设备、变形本和可拆卸外形设备而设计。

第四代处理器系列能够根据功耗要求匹配不同的显卡性能。 虽然高端产品能够提供更高的显卡性能，但是低端产品更适合需要使用低显卡性能的情况。

关于显卡能力的具体分析，请参阅显卡开发人员指南。

英特尔® AVX 2.0

英特尔® 高级矢量指令扩展集（英特尔® AVX）2.0 是一套针对英特尔® SIMD 流指令扩展（英特尔® SSE）的 256 位扩展指令集。 英特尔 AVX 2.0 基于 1.0 版并可提供在两个端口上执行完全管线化乘加融合（Fully Pipelined Fused Multiply Add）等功能，从而针对乘加工作负载提供两倍的浮点运算性能和 256 位整数 SIMD 运算，而旧版为 128 位乘加运算和二进制位处理指令。 这些性能可增强面部检测、pro-imaging、高性能计算、消费类视频和成像、增强向量（increased vectorization）及其他高级视频处理功能的使用。

有关英特尔 AVX 2.0 的更多资源：

• 英特尔® 高级矢量扩展指令集
• 英特尔® 64 和 IA-32 架构软件开发人员手册

Intel Iris Graphics Extensions to DirectX API

第四代处理器显卡中新增了面向 DirectX 扩展的 API 设置。 有两种 API 可以使用：像素同步和快速访问。 像素同步支持您有效读取/修改/写入每像素的数据，从而让混合编程和无规则透明度（OIT）处理效率更高。 快速访问支持 CPU 和 GPU 同时访问相同的内存来进行映射和渲染。 这些 API 适用于 DirectX 11 及更高版本。

有关详细信息，请参阅 显卡开发人员指南。

安全

搭载第四代处理器的超极本系统配备了 Intel® Platform Trust Technology、Intel® Insider 和英特尔® 防盗技术⁽ⁱⁱⁱ⁾等增强安全特性。 此外，该处理器还采用了英特尔® 身份保护技术^(iv)，可提供可靠的身份保护和欺诈防御。

开发人员建议

希望使用上述介绍的新特性的开发人员可以按照下列指南在采用 Windows 8 的第四代处理器上进行编程。

1. 针对触控优化应用： 搭载第四代处理器的超极本系统均支持触摸屏。 开发人员应参阅下列 UX/UI 指南来优化应用设计和启用触控功能。

    

   更多资源：

   • 超极本设备和平板电脑 Windows 触控功能开发人员指南
   • 设计面向超极本? 设备和触控桌面应用
   • 为开发人员开发桌面自然用户界面 API
   • 在 Windows* 8 应用中处理触控输入

    

2. 使用传感器优化应用： 基于第四代处理器的平台配备了多种传感器： GPS、指南针、陀螺仪、加速计和环境光。 上述传感器建议以 Microsoft 面向 Windows 8 的标准为基准。使用 Windows 传感器 API，您的代码将会在所有运行 Windows 8 的超极本和平板电脑系统上运行。

    

   更多资源：

   • 超极本和平板电脑 Windows 8 传感器开发指南
   • 检测 Windows 8 上的超极本传感器

    

3. 使用英特尔平台特性优化应用： 虽然 Windows 8 既支持桌面应用也支持 Windows 应用商店应用，但是每种类型适用的平台功能不同，Windows 8 将会有所差异。 对于桌面应用，主要功能为英特尔® 无线显示（WiDi）^(v)和安全特性（如英特尔防盗技术和英特尔身份保护技术，其中核芯显卡对于两种类型的应用均适用）。 请参阅下列资源，了解有关每种类型的更多信息。

    

   更多资源：

   • 构建面向超极本的英特尔® WiDi 应用
   • 在 Windows* 8 上启用英特尔® WiDi 消费者预览
   • 显卡开发人员指南
   • 英特尔® 防盗技术
   • 英特尔® 身份保护技术

    

   在 Windows UI 模式下，主要支持特性有联网待机、核芯显卡、支持在平板电脑上使用的触控笔输入以及摄像头。 请参阅下列资源，了解有关每种类型的更多信息：

   更多资源：

   • 英特尔智能连接技术开发
   • Windows* 桌面触控摄像头示例摘要

    

4. 通过优化获得明显的性能优势： 可以对桌面应用进行优化以采用英特尔 AVX 2.0。 可使用英特尔快速同步视频编码和后处理对媒体和视觉密集型应用进行优化。 请注意：Windows 应用商店应用也可使用英特尔媒体软件开发套件和英特尔快速同步视频。

    

   更多资源：

   • 英特尔® 媒体软件开发套件:
   • 英特尔® 高级矢量扩展指令集
   • 英特尔® 64 和 IA-32 架构软件开发人员手册

    

5. 使用英特尔® 感知计算软件开发套件的功能优化应用： 第^四代处理器内置的英特尔 AVX 2.0 功能可提供面部识别、语音识别和其他交互性特性，让桌面应用的使用极具吸引力。

    

   更多资源：

   • 英特尔® 高级矢量扩展指令集
   • 英特尔® 64 和 IA-32 架构软件开发人员手册
   • 英特尔® 感知计算软件开发套件

    

6. 使用英特尔® 工具优化应用性能： 请了解面向 Windows 桌面的英特尔® Composer XE 2013 和英特尔® VTune? Amplifier XE 2013。 上述套件可提供编译器、英特尔® 性能基元和英特尔® 线程构建模块，帮助加速应用性能。 此外，您还可使用面向桌面和 Windows 应用商店应用的英特尔® 图形性能分析器 2013 和英特尔媒体软件开发套件优化所有 IA 平台上的媒体和图形工作负载以防止其被取代。

    

   更多资源：

   • 视觉计算源

关于作者

Meghana Rao 是开发人员关系部门的技术营销工程师。 她帮助推广了超极本和平板电脑平台，也是英特尔® 开发人员专区中多篇文章的作者。

⁽ⁱ⁾第三^代英特尔® 酷睿? i7-3667U 处理器、英特尔核芯显卡 4000、Tacoma Falls 2 参考设计平台、2 个 4GB DDR3L-1600、120GB 固态硬盘、 13.3 英寸增强型显示端口面板（分辨率为 1920x1080）、50 WHr 电池、Windows* 8。

4第^四代英特尔® 酷睿? i7-4650U 处理器、英特尔核芯显卡 5000、预生产平台、2 个 2GB DDR3L-1600、120GB 固态硬盘、 13.3 英寸增强型显示端口面板（支持面板自刷新，分辨率为 1920x1080）、50 WHr 电池、Windows* 8。

⁽ⁱⁱ⁾ 3第^三代英特尔® 酷睿? i7-3687U 处理器、Tacoma Falls 2 参考设计平台、英特尔核芯显卡 4000、英特尔核芯显卡驱动程序 15.31.3063、2 个 2GB DDR3L（速率为 1600MHz）、120GB固态硬盘、13.3 英寸增强型显示端口面板（支持面板自刷新，分辨率为 1920x1080）、50 WHr 电池、Windows* 8。

第四代英特尔酷睿 i7-4770R 处理器、预生产平台、英特尔 5200、英特尔核芯显卡驱动程序 15.31.3071、2 个 2GB DDR3L（速率为 1600MHz）、160 GB 固态硬盘、Windows* 8。

⁽ⁱⁱⁱ⁾任何系统都不能在所有情况下提供绝对的安全性。 需要支持的芯片组、BIOS、固件、软件和数据加密软件，并且向支持的服务提供商进行服务激活。 有关上市时间和功能，请咨询您的系统制造商和服务提供商。 服务不一定在所有国家均提供。 因此导致的任何数据和/或系统的丢失或被盗或其它损失，英特尔将不负任何责任。 如欲了解更多信息，请访问：www.intel.com/content/www/us/en/architecture-and-technology/anti-theft/anti-theft-general-technology.html。

^(iv)任何系统都不能在所有情况下提供绝对的安全性。 需要支持英特尔® 身份保护技术的系统，包括采用第二代或更高性能的英特尔® 酷睿? 处理器的芯片、固件和软件及相关网站。 详情请咨询您的系统生产商。 英特尔对数据和/或系统丢失或被盗责任以及任何其它损失不承担任何责任。 更多信息敬请登录：http://ipt.intel.com/。

^(v)需要支持英特尔® 无线显示技术的电脑、兼容的适配器和电视。 1080p 和蓝光* 或其它受保护内容的播放仅在采用核芯显卡的基于第二代智能英特尔® 酷睿? 处理器的电脑上可用。 详情请咨询您的电脑生产商。 更多信息敬请登录：www.intel.com/go/widi。

英特尔公司© 2013 年版权所有。 所有权保留。

*其他的名称和品牌可能是其他所有者的资产。

OpenCL 和 OpenCL 标识是苹果公司的商标，需获得 Khronos 的许可方能使用。

 這是昨天一個學生問我的問題『怎麼從 Windows Store App 啟動 Desktop Application？』，這是個好問題而且引起了我的興趣，老實說，壓根兒從來沒想過這種情境，但這問題真的太有趣了，答案是：『的確有辦法從 Windows 市集應用程式啟動桌面應用程式，重點是一點也不難』，接下來就來看看是怎麼達成這樣的需求。

   一開始我想聊聊思考這問題的路子，第一個想法是：『 一個 Windows 市集應用程式如何啟動另外一個 Windows 市集應程式？』，這個答案很明顯，通常是透過 URI 或 File Association 來達成。既然如此，Windows 市集應用程式應該也可以透過這種方式來啟動桌面應用程式才對。然後我就做了一個實驗，我在 Metro IE 上打上 mms:// 的通訊協定測試是否能夠啟動Windows Media Player，結果是正確啟動的；至此，答案已經很明顯了，既然 Windows Media Player 這個桌面的應用程式可以這樣被啟動，其它的應用程式也應該可以這麼做，於是我就開始動手測試與驗證自己的想法是否正確。

整個的測試過程是這樣完成的：

        (1)  先做一個 Windows Forms Application 當做要被呼叫的對象，這個程式畫面只有一個 Lable，但為了要讓啟動時可以傳參數，稍微修改了一些東西。

Program.cs

Form1.cs

(2) 接著我在電腦的機碼中新增自訂的 URI Protocol, 命名為 callbill，參考 Registering an Application to a URI Scheme

(3) 最後新增一個 Windows 市集應用程式專案，在 UI 上放一個 Button ，為 Button.Click 事件撰寫委派函式如下

執行 Windows 市集應用程式，按下 Button 的最後結果

Download article

Using Intel® Graphics Performance Analyzers to Optimize Splinter Cell*: Blacklist* [PDF 559KB]

For the most recent installment of Tom Clancy’s* Splinter Cell series, engineers from Ubisoft and Intel analyzed the game to make it run smoothly and achieve the best performance on Intel® hardware. Using Intel® Graphics Performance Analyzers (Intel® GPA), we found some bottlenecks in the frame. Ubisoft was then able to optimize the draw calls we identified, tripling the frame rate. The expensive rendering passes we found were the lighting environment pass and the shadow pass. On a 4^th generation Intel® Core™ i7 processor-based desktop, a frame rate of 43 frames per second (fps) was achieved at 1366x768 resolution with low settings, 35 fps on medium settings.

Specifying a Workload

Optimizing a game is full of experiments—changing shaders, using different textures, trying new approaches—to find troublesome components or rendering passes and increase the speed. As with any experiment, an analytical approach is vital in determining the quality of the results. An in-game workload (representative scene where performance is lacking) should be chosen for the analysis. Figure 1 shows one such scene: numerous objects, multiple light sources, and several characters.

Figure 1. Scene chosen for analysis.

Identifying and Addressing the Problems

To see what’s going on here, we used the Intel GPA Monitor to remotely capture a frame for analysis. Loading that in the Intel GPA Frame Analyzer, the problematic ergs (units of work, from the Greek ἔργον (ergon) meaning “work”) can be identified by their charted size, the amount of time the GPU spends on them. By inspecting the ergs individually and mapping them to stages in the game’s pipeline, we isolated two main issues (figure 2): the SeparableSSS pass and the lighting environment pass. The SeparableSSS pass was removed due to the extremely high cost.

Figure 2. Erg view of Intel® GPA frame capture before optimization

This definitely helped the overall performance. With these two ergs out of the way, the lighting environment pass was our next area to tackle. It was problematic not solely because of the amount of time spent on each erg, but the large number of ergs used, combining to constitute a prohibitive amount of total GPU time: ~100 x 1500 μs = 150,000 μs! Figure 3 makes this painfully clear.

Figure 3. Lighting environment pass grows prohibitive

Figure 4 shows the gains after optimizing the lighting environment pass.

Figure 4. Removing the lighting environment pass sped things up significantly

The two ergs tied for second place in height are the ShadowPass.Composite function. These were also optimized.

Final Results

After these changes, combining the highly effective shadow compositing into the rendering passes brought processing costs still lower (figure 5).

Figure 5. Intel® GPA frame capture after optimization

Overall, the performance approximately tripled, achieving 43 fps at 1366x768 resolution with low settings (35 fps on medium settings) on a 4^th generation Intel Core i7 processor-based desktop.

Conclusion

Approaching optimization like a series of experiments is useful in finding the root causes of your performance problems. The issues outlined here represent just a few ways to use Intel GPA to streamline your applications. Many more can be found through the documentation, online forums, and articles on Intel® Developer Zone.

About the Author

Brad Hill is a Software Engineer at Intel in the Developer Relations Division. Brad investigates new technologies on Intel hardware and shares the best methods with software developers via the Intel Developer Zone and at developer conferences. He also runs Code for Good Student Hackathons at colleges and universities around the country.

Intel, the Intel logo, and Core are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.

Downloads

How to Integrate Intel® Perceptual Computing SDK with Cocos2D-x [PDF 482KB]

Introduction

In this article, we will explain the project we worked on as part of the Intel® Perceptual Computing Challenge Brazil, where we managed to achieve 7th place. Our project was Badaboom, a rhythm game set in the Dinosaur Era where the player controls a caveman, named Obo, by hitting bongos at the right time. If you’re curious to see the game in action, check out our video of Badaboom:

​

To begin, you’ll need to understand a bit about Cocos2D-X, an open-source game engine that is widely used to create games for iPhone* and Android*. The good thing about Cocos2D-X is that it is cross-platform and thus is used to create apps for Windows* Phone, Windows 8, Win32*, Linux*, Mac*, and almost any platform you can think of. For more information, go to www.cocos2dx.org.

We will be using the C++ version of the SDK (Version 9302) as well as the Cocos2D-X v2.2 (specifically the Win32 build with Visual Studio* 2012). Following the default pattern of Cocos2D, we will create a wrapper that receives and processes the data from the Creative* Interactive Gesture Camera and interprets it as “touch” for our game.

Setting the environment

To start, you’ll need to create a simple Cocos2D project. We will not cover this subject as it is not the focus of our article. If you need more information, you can find it on the Cocos2D wiki (www.cocos2dx.org/wiki).

To keep it simple, execute the Python* script to create a new project in the “tools” folder of Cocos2d-x and open the Visual Studio project. Now we will add the Intel Perceptual Computing SDK to the project.

To handle the SDK’s input, we will create a singleton class named CameraManager. This class starts the camera, updates the cycle, and adds two images to the screen that represent the position of the hands on the game windows.

CameraManager is a singleton class that is derived from UtilPipeline and imports the “util_pipeline.h” file. Here, we need to reconfigure some of the Visual Studio project properties. Figure 1 shows how to add the additional include directories for the Intel Perceptual Computing SDK.

   $(PCSDK_DIR)/include
   $(PCSDK_DIR)/sample/common/include
   $(PCSDK_DIR)/sample/common/res

Figure 1. Additional include directories

You must also include the following paths to the additional library directories:

   $(PCSDK_DIR)/lib/$(PlatformName)
   $(PCSDK_DIR)/sample/common/lib/$(PlatformName)/$(PlatformToolset)

Figure 2. Additional Library Directories

Add the following dependencies in the input section:

   libpxc_d.lib
   libpxcutils_d.lib

Figure 3. Additional Dependencies

Now we are ready to work on our CameraManager!

Start Coding!

First we need to make the class a singleton. In other words, the class needs to be accessible from anywhere in the code with the same instance (singleton classes have only one instance). For this, you can use a method:

CameraManager* CameraManager::getInstance(void)
{
    if (!s_Instance)
    {
        s_Instance = new CameraManager();
    }

    return s_Instance;
}

After that, we’ll build a constructor, a method that starts the camera:

CameraManager::CameraManager(void)
{
	if (!this->IsImageFrame()){
		this->EnableGesture();

		if (!this->Init()){
			CCLOG("Init Failed");
		}
	}

	this->hand1sprite = NULL;
	this->hand2sprite = NULL;

	hasClickedHand1 = false;
	hasClickedHand2 = false;

	this->inputAreas = CCArray::createWithCapacity(50);
	this->inputAreas->retain();
}

Many of the commands initialize variables that handle sprites which symbolize the users’ hands and get input as they close their hands. The next step is processing the data that comes from the camera.

void CameraManager::processGestures(PXCGesture *gesture){
	
	PXCGesture::Gesture gestures[2]={0};

	gesture->QueryGestureData(0,PXCGesture::GeoNode::LABEL_BODY_HAND_PRIMARY,0,&gestures[0]);
	gesture->QueryGestureData(0,PXCGesture::GeoNode::LABEL_BODY_HAND_SECONDARY,0,&gestures[1]);

	
	CCEGLView* eglView = CCEGLView::sharedOpenGLView();
	switch (gestures[0].label)
	{
	case (PXCGesture::Gesture::LABEL_POSE_THUMB_DOWN):
		CCDirector::sharedDirector()->end();
		break;
	case (PXCGesture::Gesture::LABEL_NAV_SWIPE_LEFT):
		CCDirector::sharedDirector()->popScene();
		break;
	}
}

To be clear, it is in this method that you can also add switch cases to understand voice commands and to implement more gesture handlers. Following this, we must process this information and display it in the CCLayer (Cocos2D sprite layer).

bool CameraManager::Start(CCNode* parent){
	this->parent = parent;

	if (this->hand1sprite!=NULL
    &&  this->hand1sprite->getParent()!=NULL){
		this->hand1sprite->removeFromParentAndCleanup(true);
		this->hand2sprite->removeFromParentAndCleanup(true);
	}

	this->hand1sprite = CCSprite::create("/Images/hand.png");
	this->hand1sprite->setOpacity(150);
    //To make it out of screen
	this->hand1sprite->setPosition(ccp(-1000,-1000));
	this->hand1Pos = ccp(-1000,-1000);
	
	this->hand2sprite = CCSprite::create("/Images/hand.png");
	this->hand2sprite->setFlipX(true);
	this->hand2sprite->setOpacity(150);
	this->hand2sprite->setPosition(ccp(-1000,-1000));
	this->hand2Pos = ccp(-1000,-1000);

	parent->addChild(this->hand1sprite, 1000);
	parent->addChild(this->hand2sprite, 1000);
	
	this->inputAreas->removeAllObjects();
	return true;
}

This method should be called each time a new frame is placed on the screen (most of the time into the onEnter callback). It will automatically remove the hand sprites from the previous parent and add them to the new CCLayer.

Now that our hand sprites have been added to the CCLayer we are able to handle their position by calling the follow method on the update cycle of the CCLayer (which is scheduled by the call: “this->scheduleUpdate();”). The update method is as follows:

void CameraManager::update(float dt){

	if (!this->AcquireFrame(true)) return;

	PXCGesture *gesture=this->QueryGesture();
	
	this->processGestures(gesture);

	PXCGesture::GeoNode nodes[2][1]={0};
	
    gesture->> QueryNodeData(0,PXCGesture::GeoNode::LABEL_BODY_HAND_PRIMARY,1,nodes[0]);
	gesture-> QueryNodeData(0,PXCGesture::GeoNode::LABEL_BODY_HAND_SECONDARY,1,nodes[1]);

	CCSize _screenSize = CCDirector::sharedDirector()->getWinSize();

	
	if (nodes[0][0].openness<20 && !this->hand1Close){
		this->hand1sprite->removeFromParentAndCleanup(true);
		this->hand1sprite = CCSprite::create("/Images/hand_close.png");
		this->hand1sprite->setOpacity(150);
		this->parent->addChild(hand1sprite);
		this->hand1Close = true;
	} else if (nodes[0][0].openness>30 && this->hand1Close) {
		this->hand1sprite->removeFromParentAndCleanup(true);
		this->hand1sprite = CCSprite::create("/Images/hand.png");
		this->hand1sprite->setOpacity(150);
		this->parent->addChild(hand1sprite);
		this->hand1Close = false;
	}
	
	if (nodes[1][0].openness<20 && !this->hand2Close){
		this->hand2sprite->removeFromParentAndCleanup(true);
		this->hand2sprite = CCSprite::create("/Images/hand_close.png");
		this->hand2sprite->setFlipX(true);
		this->hand2sprite->setOpacity(150);
		this->parent->addChild(hand2sprite);
		this->hand2Close = true;
	} else if (nodes[1][0].openness>30 && this->hand2Close) {
		this->hand2sprite->removeFromParentAndCleanup(true);
		this->hand2sprite = CCSprite::create("/Images/hand.png");
		this->hand2sprite->setFlipX(true);
		this->hand2sprite->setOpacity(150);
		this->parent->addChild(hand2sprite);
		this->hand2Close = false;
	}

	this->hand1Pos = ccp(_screenSize.width*1.5-nodes[0][0].positionImage.x*(_screenSize.width*HAND_PRECISION/320) + 100,
						 _screenSize.height*1.5-nodes[0][0].positionImage.y*(_screenSize.height*HAND_PRECISION/240));
	this->hand2Pos = ccp(_screenSize.width*1.5-nodes[1][0].positionImage.x*(_screenSize.width*HAND_PRECISION/320) - 100,
						 _screenSize.height*1.5-nodes[1][0].positionImage.y*(_screenSize.height*HAND_PRECISION/240));

	if (!hand1sprite->getParent() || !hand2sprite->getParent()){
		return;
	}
	this->hand1sprite->setPosition(this->hand1Pos);
	this->hand2sprite->setPosition(this->hand2Pos);

	
    CCObject* it = NULL;
	CCARRAY_FOREACH(this->inputAreas, it)
	{
		InputAreaObject* area = dynamic_cast<InputAreaObject*>(it);
		this->checkActionArea(area->objPos, area->radius, area->sender, area->method);
	}
			
	this->ReleaseFrame();

}

This code not only handles the position of the sprite, it also sets a different sprite (hand_close.png) if the camera detects that the hand is less than 20% open. In addition to this, there is simple logic to create hand precision, which makes the user input more sensitive and easier to get the edges of the screen. We do this because the Perceptual Camera is not that precise on the edges, and the position of the sprites commonly get crazy when we approach the edge.

Now it is indispensable that we add some ways to handle the input (a closed hand is considered a touch). We need to write a method called “checkActionArea” (called in the update method) and register the actionArea.

void CameraManager::checkActionArea(CCPoint objPos, float radius, CCObject* sender, SEL_CallFuncO methodToCall){

	if (sender==NULL)
		sender = this->parent;

	float distanceTargetToHand = ccpDistance(this->hand1Pos, objPos);
	if (distanceTargetToHand<radius){
		if (this->hand1Close&& !hasClickedHand1){

			this->parent->runAction(CCCallFuncO::create(this->parent, methodToCall, sender));
			hasClickedHand1 = true;
		}
	}
	
	if (!this->hand1Close){
		hasClickedHand1 = false;
	} //TODO: repeat for hand2
}

Follow the method registerActionArea() for the registration of areas:

void CameraManager::registerActionArea(CCPoint objPos, float radius, cocos2d::SEL_CallFuncO methodToCall){

	InputAreaObject* newInputArea = new InputAreaObject(objPos, radius, methodToCall);
	this->inputAreas->addObject(newInputArea);
}

Now it is easy to add the Intel Perceptual Computing SDK to your Cocos2D game!!! Just run:

CameraManager::getInstance()->Start(this);

When entering the Layer, register the objects and methods to be called:

CameraManager::getInstance()->registerActionArea(btn_exit->getPosition(), 150, callfuncO_selector(LevelSelectionScene::backClicked));

About us!

Intel and the Intel logo are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.

By Lynn Thompson

Downloads

Implementing Multiple Touch Gestures Using Unity* 3D with TouchScript [PDF 1.48MB]

This article provides an overview and example for the several TouchScript gestures (Press, Release, Long Press, Tap, Flick, Pan, Rotate, and Scale) available when developing touch-based Unity* 3D simulations and applications running on Ultrabook™ devices with the Windows* 8 operating system. TouchScript is available at no cost from the Unity 3D Asset Store.

The example used in this article starts with a preconfigured scene imported from Autodesk 3ds Max*. I then add geometry to the Unity 3D scene to construct graphical user interface (GUI) widgets that accept touch input from the user. The multiple gestures available via TouchScript will be implemented and customized such that adjustments to the widget can be made during runtime, allowing for a GUI widget that can provide a touch UI that is acceptable to a wider audience when running a Unity 3D-based application on Window 8.

Creating the Example

I first import into Unity 3D an Autodesk 3ds Max FBX* export that contains a few geometry primitives and a small patch of banyan and palm trees (see Figure 1). I add a first-person controller to the scene; then, I assign a box collider to the box primitive imported from Autodesk 3ds Max, which acts as the scene’s floor, to prevent the first-person controller from falling out of the scene.

Figure 1. Unity* 3D editor with a scene imported from Autodesk 3ds Max*

Next, I add eight spheres (LeftLittleTouch, LeftRingTouch, LeftMiddleTouch, LeftIndexTouch, RightLittleTouch, RightRingTouch, RightMiddleTouch, and RightIndexTouch) as children of the main camera, which is a child of the first-person controller. I give these spheres a transform scale of x = 0.15 y = 0.30 z = 0.15 and position them in front of the main camera in a manner similar to fingertips on a flat surface. I add a point light above the modified spheres and make a child of the main camera to ensure illumination of the spheres. The layout of these modified spheres is shown in Figure 2.

Figure 2. Unity* 3D runtime with a first-person controller and modified spheres as children for the touch interface

This ends the base configuration of the example. From here, I add TouchScript gestures to the modified spheres and configure scripts to generate a desired touch response.

Adding Press and Release Gestures

The first-person controller from the initialization step of the example contains the JavaScript* file FPSInput Controller.js and the C# script Mouse Look.cs. The FPSInput Controller.js script takes input from the keyboard; Mouse Look.cs, obviously, takes input from the mouse. I modified these scripts to contain public variables that replace vertical and horizontal inputs into FPSInput Controller.js and to replace mouseX and mouseY inputs into the Mouse Look.cs script.

This replacement is fairly straightforward in FPSInputController.js because the keyboard sending a 1, −1, or 0 to the script is replaced with a touch event that results in public variables being changed to a 1, −1, or 0. The touch objects, their respective scripts, and the values they send to script FPSInputController are provided in Table 1 and can be viewed in their entirety in the Unity 3D FirstPerson project accompanying this article.

Table 1. Touch Objects and Corresponding Scripts in FPSInputController.js

This method works for controller position because the information is discrete, as are the TouchScript onPress and onRelease functions. For rotation, an angle variable needs to be updated every frame. To accomplish this, I send a Boolean value to a Mouse Look.cs public variable, and the rotation angle is changed in the Mouse Look.cs Update function at a rate of 1 degree per frame accordingly. The touch objects, their respective scripts, and the values they send to the Mouse Look.cs script are provided in Table 2 and can be viewed in their entirety in the Unity 3D FirstPerson project accompanying this article.

Table 2. Touch Objects and Corresponding Scripts in Mouse Look.cs

These scripts allow touch interface for first-person shooter (FPS) position and rotation control, replacing keyboard and mouse input.

Using the LongPress Gesture

My original intent for this example was to have the LongPress Gesture make all the touch objects disappear after at least one object had been pressed for a certain amount of time. The touch objects would then all reappear after all touch objects had instigated a release gesture and had not been touched for a certain amount of time. When I tried implementing it this way, however, the behavior was not as I expected, possibly because the LongPress Gesture was used in conjunction with the standard Press and Release Gestures. As a workaround, I implemented this functionality by using the already-implemented Press and Release Gestures in combination with public variables and the delta time method in the system timer.

When initially setting up the Unity 3D scene, I configured a TopLevelGameObject asset to hold the TouchScript Touch Manager and the TouchScript Windows 7 Touch Input script. To facilitate the desired LongPress Gesture, I added a custom C# script named PublicVariables.cs to the TopLevelGameObject asset. I did this not only to hold public variables but also to perform actions based on the state of these variables.

To configure this disappear and reappear functionality, I configured each move and look script associated with its respective touch sphere to have access to the public variables in PublicVariables.cs. PublicVariables.cs contains a Boolean variable for the state of each modified sphere’s move or look Press Gesture, being true when the modified sphere is pressed and false when it is released.

The PublicVariables.cs script uses the state of these variables to configure a single variable used to set the state of each modified sphere’s MeshRenderer. I configure the timer such that if any modified sphere or combination of modified spheres has been pressed for more than 10 seconds, the variable controlling the MeshRenderer state is set to False. If all of the spheres have been released for more than 2 seconds, the MeshRenderer state is set to True. Each move and look script has in its Update function a line of code to enable or disable its respective sphere’s MeshRenderer based on the state of this variable in PublicVariables.cs.

This code results in all of the modified spheres disappearing when any sphere or combination of spheres has been pressed for more than 10 consecutive seconds. The modified spheres then all reappear if all modified spheres have been released for more than 2 seconds. By enabling and disabling the modified spheres’ MeshRenderer, only the modified sphere’s visibility is affected, and it remains an asset in the scene and is able to process touch gestures. As such, the modified spheres are still used to manipulate the scene’s first-person controller. The user is required to intuitively know where the spheres are positioned and be able to use them while they are not being rendered to the screen. Examine the PublicVariables, Move, and Look scripts in the example provided to see the code in its entirety.

The Tap Gesture

To demonstrate the use of multiple gestures with one asset, I add the Tap Gesture to all four move spheres. The Tap Gesture is configured in all four of the left GUI widget’s modified spheres’ respective move scripts. The move scripts are then configured for access to the first-person controller’s Character Motor script. I configure the tap functions in each move script to manipulate the maximum speed variables in the Character Motor’s movement function.

The MoveForward script attached to the LeftRingTouch modified sphere is configured so that a Tap Gesture increases the maximum forward speed and maximum reverse speed by one. I configure the MoveReverse script attached to the LeftIndexTouch modified sphere for a Tap Gesture to decrease the maximum forward speed and maximum reverse speed by one. I configure the MoveLeft script attached to the LeftLittleTouch modified sphere for a Tap Gesture to increase the maximum sideways speed by one and the MoveRight script attached to the LeftMiddleTouch modified sphere for a Tap gesture to decrease the maximum sideways speed by one. The maximum speed variables are floating-point values and can be adjusted as desired.

When using the default settings with the Tap Gesture, the speeds change during the period when the user may want to press the modified sphere to instigate movement. In short, Press and Release Gestures are also considered Tap Gestures. To mitigate this behavior, I changed the Time Limit setting in the Will Recognize section of the Tap Gesture (see Figure 3) from Infinity to 0.25. The lower this setting, the sharper the tap action must be to instigate the Tap Gesture.

Figure 3. Unity* 3D editor showing a modified Time Limit setting in a Tap Gesture

The modified sphere can be used to navigate the scene and adjust the speed at which the scene is navigated. A quirk of this method for navigating and adjusting speed is that when a Tap Gesture is used to adjust speed, the first-person controller is also moved in the direction associated with the modified sphere that was tapped. For example, tapping the LeftIndexTouch modified sphere to decrement the maximum forward speed and maximum reverse speed slightly moves the first-person controller, and subsequently the scene’s main camera, in reverse. In the accompanying Unity 3D project, I add GUI labels to display the maximum speed setting so that the labels can be visualized when tapping the modified spheres. You can remove this quirk by adding a GUI widget component that, when used, disables the Press and Release Gestures, allowing the user to tap the GUI widget component without moving the main scene’s camera. After the maximum forward speed and maximum reverse speed are set to the user’s preference, the new GUI widget component can be used again to enable the Press and Release Gestures.

When developing this portion of the example, I intended to add a Flick Gesture in combination with the Tap Gesture. The Tap Gesture was going to increase speed, and the Flick Gesture was intended to decrease speed. However, when adding both the Flick and the Tap Gestures, only the Tap Gesture was recognized. Both worked independently with the Press and Release Gestures, but the Flick Gesture was never recognized when used in conjunction with the Tap Gesture.

The Flick Gesture

To demonstrate the Flick Gesture, I add functionality to the modified spheres on the right side of the screen. The look scripts are attached to these spheres and control the rotation of the scene’s main camera, which is a child of the first-person controller. I begin by adding a Flick Gesture to each sphere. I configure the Flick Gestures added to the RightTouchIndex and RightTouchRing modified spheres that control horizontal rotation with their touch direction as horizontal (see Figure 4). I configure the Flick Gestures added to the RightTouchMiddle and RightTouchLittle modified spheres that control vertical rotation with their touch direction as vertical. This may be useful when the modified spheres have disappeared after being pressed for 10 or more seconds and the touch interface does not respond to the user’s flick (as opposed to responding in an undesired manner). The user then knows that the touch interface–modified spheres need to be released, allows 2 seconds for the modified spheres to reappear, and then reengages the touch GUI widget.

Figure 4. Unity* 3D editor showing a modified Direction setting in a Flick Gesture

Each look script uses the public variables that exist in the Mouse Look script. When a modified sphere is flicked, the Mouse Look script instigates a rotation in the respective direction, but because there is no flick Release Gesture, the rotation continues indefinitely. To stop the rotation, the user must sharply press and release the modified sphere that was flicked. This action causes an additional degree of rotation from the Press Gesture but is followed by the Release Gesture, which sets the respective rotation public variable to False, stopping the rotation.

Like the Tap Gesture, the Flick Gesture now works in conjunction with the Press and Release Gestures. Users can still rotate the scene’s main camera by holding down the appropriate modified sphere, releasing it to stop the rotation. With the Flick Gesture implemented, users can also flick the desired modified sphere to instigate a continuous rotation that they can stop by pressing and releasing the same modified sphere.

The Remaining Gestures

To this point in the example, all of the gestures implemented enhance the user’s ability to directly navigate the scene. I use the remaining gestures (Rotate, Scale, and Pan) to allow the user to modify the touch targets’ (the modified spheres) layout for improved ergonomics.

Also, up to this point, all of the gestures are discrete in nature. An immediate action occurs when a Unity 3D asset is tapped, pressed, released, or flicked. This action may be the setting of a variable that results in a continuous action (the flick-instigated rotation), but the actions are discrete in nature. The Rotate, Scale, and Pan Gestures are continuous in nature. These gestures implement a delta method where the difference between the current state of the gesture and that of the previous frame is used in the script to manipulate a Unity 3D screen asset as desired.

The Rotate Gesture

I add the Rotate Gesture in the same way as previous gestures. I use the Add Component menu in the Inspector Panel to add the TouchScript gesture, and the script attached to the touch asset receiving the gesture is modified to react to the gesture. When implemented, the Rotate Gesture is instigated by a movement similar to using two fingers to rotate a coin on a flat surface. This action must occur within an area circumscribed by the Unity 3D asset receiving the gesture.

In this example, rotating the modified spheres results in the capsule shape becoming more of a sphere as the end of the modified sphere is brought into view. This behavior gives the user an alternate touch target interface, if desired. In this example, this functionality is of more use for the modified spheres on the right side of the screen. For the rotate widget on the right side of the screen, the user can flick the appropriate modified sphere for constant rotation up, down, left, or right. I configure the modified spheres controlling vertical rotation with vertical flicks. I configure the modified spheres controlling horizontal rotation with horizontal flicks. The modified spheres controlling horizontal rotation can now be rotated so that the longest dimension is horizontal, allowing for a more intuitive flicking action.

When rotating the modified spheres that are closest to the center of the screen, the modified spheres take on a more spherical appearance. The farther away from the center screen the modified sphere is when being rotated, the modified sphere takes on a more capsule-like appearance. This is an effect of the modified sphere’s distance from the scene’s main camera. It may be possible to mitigate this affect by adjusting the axes on which the modified sphere rotates. The following line of code does the work of rotating the modified sphere when the Rotate Gesture is active:

targetRot = Quaternion.AngleAxis(gesture.LocalDeltaRotation, gesture.WorldTransformPlane.normal) * targetRot;

The second argument in the Quaternion.AngleAxis is the axis on which the modified sphere rotates. This argument is a Vector3 and can be changed as follows:

targetRot = Quaternion.AngleAxis(gesture.LocalDeltaRotation, new Vector3(1, 0, 0)) * targetRot;

By adjusting this Vector3 as a function of the modified sphere’s distance from the position relative to the scene’s main camera, I can remove the effect, resulting in the modified sphere’s appearance being more consistent and spherical across all the spheres.

The Scale Gesture

I add the Scale Gesture as an additional means of altering the modified sphere’s presentation. When rotated, the resulting circular touch target may not be large enough for the user’s preference. The user can employ the Scale Gesture to modify the size of the touch target.

The motion used to instigate a Scale Gesture is similar to the Pinch Gesture used on mobile devices. Two fingers are moved apart and brought together for a scale-down gesture. The fingers are together and moved apart to instigate a scale-up gesture. The code in the accompanying Unity 3D project scales the target asset uniformly. This is not required: You can code for scaling on any combination of the x, y, or z axes.

An additional feature that may help with user utilization of the GUI widgets is automatic scaling following the 10 seconds of constant use, resulting in the disappearance of the GUI widgets. By automatically multiplying a modified sphere’s transform.localscale by 1.1 whenever the modified sphere’s MeshRenderer has been disabled, the user automatically gets a larger touch target, which may reduce the user’s need to intermittently release the GUI widgets to confirm the modified sphere’s location on the touch screen.

The Pan Gesture

For the purposes of ergonomics, the Pan Gesture is probably the most useful gesture. It allows users to touch the objects to be manipulated and drag them anywhere on the screen. As the modified spheres are initially positioned, users may, depending on the Ultrabook device they are using, have wrists or forearms resting on the keyboard. With the Pan Gesture functionality implemented, users can drag the modified spheres to the sides of the screen, where there may be less chance of inadvertently touching the keyboard. For additional ergonomic optimization, users can touch all four modified spheres that affect the first-person controller and drag them at the same time to a place on the screen that allows them to rest their wrists and arms as desired.

The following two lines of code, taken from a Unity 3D example, do the work of moving the Unity 3D scene asset when the Pan Gesture is active:

var local = new Vector3(transform.InverseTransformDirection(target.WorldDeltaPosition).x, transform.InverseTransformDirection(target.WorldDeltaPosition).y, 0);
targetPan += transform.parent.InverseTransformDirection(transform.TransformDirection(local));

Note that in the above code, the z component of the Vector3 is zero and that in the accompanying example, when the modified spheres are moved, or panned, they move only in the x–y plane. By modifying this Vector3, you can customize the interface a great deal. The first example that comes to mind is having a Pan Gesture result in a much faster Unity 3D asset motion on one axis than another.

In the “Everything” example provided with TouchScript, the following line of code limits the panning of the manipulated asset on the y-axis:

if(transform.InverseTransformDirection(transform.parent.TransformDirection(targetPan - startPan)).y < 0) targetPan = startPan;

This line was commented out in the accompanying example but can easily be modified and implemented if you want to limit how far a user can move a GUI widget component from its original position.

http://software.intel.com/en-us/videos/touch-script-multi-gesture-example

Video 1: Touch Script Multi Gesture Example

Resolving Issues During Development of the Example

One issue I found during development was that the Rotate Gesture never seemed to be recognized when the Press, Release, and Tap Gestures were added. To work around this issue, I added a modified sphere to the GUI widget on the left side of the screen intended for use by the left thumb. I configured this modified sphere with a script (ToggleReorganize.cs) so that when a user taps the modified sphere, a Boolean variable is toggled in the PublicVariables script. All of the modified sphere’s scripts reference this variable and disable their Press, Release, Tap, or Flick Gesture when the toggle variable is True, resulting in a UI that requires the user to tap the left thumb button to modify the widget. The user must then tap this left thumb button again when finished modifying the widget to go back to navigating the scene.

During the process of implementing this functionality, I discovered that the right widget did not require this functionality for the widget to be modified. The user could rotate, pan, and scale the widget without tapping the left thumb modified sphere. I implemented the functionality anyway, forcing the user to tap the left thumb modified sphere in the left widget to alter the ergonomics of the right widget. I did this because the right widget became awkward to use when it was modified at the same time it was being used to navigate the scene.

Looking Ahead

In addition to the Unity 3D scene navigation control, users can customize the GUI widgets. They can rotate, scale, and move (pan) the components of the widget to suit their ergonomic needs. This functionality is valuable when developing applications that support multiple platforms, such as Ultrabook devices, touch laptops, and tablets. These platforms can be used in any number of environments, with users in a variety of physical positions. The more flexibility the user has to adjust GUI widget configuration in these environments, the more pleasant the user’s experience will be.

The GUI widgets used in the accompanying example can and should be expanded to use additional GUI widget components designed for thumb use that can control assets in the game or simulation or control assets that are components of the GUI widgets. This expansion may include items in the simulation, such as weapons selection, weapons firing, camera zoom, light color, and jumping. To alter the GUI widget components, these thumb buttons can change the modified spheres to cubes or custom geometry. They can also be used to change the opacity of a material or color that GUI widget components use.

Conclusion

This article and the accompanying example show that using TouchScript with Unity 3D is a valid means of implementing a user-configurable GUI widget on Ultrabook devices running Windows 8. The GUI widgets implemented in the example provide a touch interface for the Unity 3D first-person controller. This interface can similarly be connected to the Unity 3D third-person controller or custom controllers simulating an overhead, driving, or flying environment.

When developing Unity 3D GUI widgets for Ultrabook devices running Windows 8, the desired result is for users to not revert back to the keyboard and mouse. All of the functionality that is typically associated with a legacy UI (a keyboard and mouse first-person controller) should be implemented in a production-grade touch interface. By taking this into consideration when implementing the TouchScript gestures described in this article and the accompanying example, you can greatly increase your prospects for obtaining a positive user response.

Note: The example provided with this article uses and references the examples provided with TouchScript as downloaded at no cost from the Unity 3D Asset Store.

About the Author

Lynn Thompson is an IT professional with more than 20 years of experience in business and industrial computing environments. His earliest experience is using CAD to modify and create control system drawings during a control system upgrade at a power utility. During this time, Lynn received his B.S. degree in Electrical Engineering from the University of Nebraska, Lincoln. He went on to work as a systems administrator at an IT integrator during the dot com boom. This work focused primarily on operating system, database, and application administration on a wide variety of platforms. After the dot com bust, he worked on a range of projects as an IT consultant for companies in the garment, oil and gas, and defense industries. Now, Lynn has come full circle and works as an engineer at a power utility. He has since earned a Masters of Engineering degree with a concentration in Engineering Management, also from the University of Nebraska, Lincoln.

Intel, the Intel logo, and Ultrabook are trademarks of Intel Corporation in the U.S. and/or other countries.
Copyright © 2013 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.

This tutorial will help to setup your floating license environment very quickly.
Follow these steps and choose the setup scenario that matches best:

• Obtain your license file
• Set up the license manager
• Set up clients

Obtain your License File

Please refer to the note 'Who is eligible to obtain a license file?' below.
You need a MAC address of the license server (optional the license server name) to register and create your license file.

1. Obtain a MAC address of the license server.
   If you have the license manager tools already installed you can run:
       lmutil lmhostid
   and take any of the addresses issued. 
   Otherwise run:
   OS X*, Linux*:
       ifconfig
       and take any of the 'HWaddr' values displayed
   Windows*:
       ipconfig /all
   and take any of the 'Physical Address' values displayed
   Note:
   Remove all special characters from the string and - if required - fill up with leading zeros to get your 12-digits alphanumeric string which is your Host ID.

2. Obtain the license server name (optional)
   Specifying the real server name is optional at the registration step. You can enter a placeholder during registration and modify the server name in the license file later with a plain text editor.
   Linux / OS X:
        hostname
   Windows:
        echo %COMPUTERNAME%
    
3. Register your Serial Number
   Login to the Intel® Registration Center and enter your SN and email, or if you are already logged in, your SN at the bottom of the "My Products" page.
   Enter your Host ID and server name you obtained in Step 1.
   The license file will be emailed to the email address associated with your license registration.
   
   Note:
   Registration of the Intel® Cluster Studio XE for Linux* is a two-steps process. During registration you need to accept the product EULA. If you missed to accept the EULA you will not get a license file attached to the registration notification email from Intel. In that case visit IRC and register this serial number again where you will have the chance to accept the EULA.

Who is eligible to obtain a license file?

Only the license owner or license administrator can perform a license registration and obtain a license file. Registered users have the right to download products and have read-access to the license history only.

    How can I identify which role I have?

1. Login to the Intel Registration Center
2. Click on the related product on the left hand column "Product Subscription Information", for example:     
3. On the 'Subscription History' page click on 'Manage', for example:
       
4. If you have access to the 'Manage' too you are either the owner or license administrator. Registered users don't have access to the 'Manage' tool.
5. If you have access you will see the Manage Page where you can see who the license owner and the license administrator are, for example:
       
    

Set up the License Manager

You can use an existing FlexNet or FlexNet Publisher license manager (lmgrd) if its version is the same or higher as the version of the Intel vendor daemon (INTEL). The description in this section applies also to a redundant servers installation where all steps need to be done on all 3 license servers.
A single license server or a redundant license server configuration can manage licenses from clients running on different operating systems.
Please refer also to the Floating Licenses and Software License Manager Compatibility section.
Please set up your license manager according to one of the following scenarios that match best:

I have to install a new license manager on a license server

1. Download
   Go to the License Manager Download Page (if you are logged out from IRC, the login prompt appears first)
   Select the right platform from the drop-down menu and download the right version:
   _ia32: is for 32-bit operating systems
   _intel64 is for Intel® 64 operating systems
   The Intel® Software License Manager User's Guide is also available from this download page.
   Notes:
   - On the license manager download page there is the most current version available only.
   - Access problems to this site indicate that you don't have a valid floating license registration associated to your email.
   - Only license owners and license administrators have access to that site

2. Installation
   Linux* / OS X*:
   - Copy the downloaded file into the directory you want to install the license server.
   - Extract the downloaded file, for example:
          tar xzvf l_isl_server_p_2.2.005_intel64.tar.gz  (Linux)
          tar xzvf m_isl_server_p_2.2.005.tar.gz  (OS X)
   - Change to directory flexlm and run the installer, for example:
         cd flexlm 
         Install_INTEL
   Windows:
   - Run the self-extracting w_isl_server_p_2.xxx.exe file and follow the instructions provided with the graphical installation wizard.
    
3. Start the license manager
   Linux* / OS X*:
   From the license manager directory /flexlm start the license manager lmgrd. You can specify a single license file or a license directory (if you more license files). By default, the license file name is server.lic which was created by the license manager installation. However you can move any valid floating license into the /flexlm directory and start it with the license manager. Creating a log file with option -l is optional.
        lmgrd -c server.lic -l flexnet_logfile.txt (reads server.lic license file and creates logfile)
        lmgrd -c . -l flexnet_logfile.txt               (reads al .lic files from the flexlm directory and creates logfile)
   Windows:
   You can run the license manager under Windows as system service (recommended) or as user application in a command shell (sometimes required for some Windows OS versions).
   System service:
   - Start > Intel(R) Software Development Products > Intel(R) Software License Manager and browse to the license file.
   User application:
   - Open a command shell
   - Navigate to c:\Program Files (x86)\Common Files\Intel\LicenseServer\
   - lmgrd -c server.lic -l flexnet_logfile.txt      (reads server.lic license file and creates logfile)

I need to add another Intel software license to an existing installation.
You can combine licenses into one single license file (.lic) or copy all license files into a license directory
   
     Combine licenses

1. Make sure that the SERVER and VENDOR lines are identical
2. Remove the SERVER and VENDOR lines of your new license file
3. Copy rest of contents of new license into the existing license file
4. Have the license manager re-read the combined license file, for example
        lmgrd lmreread –c <combined_license_file>
   On Windows you can re-read the new license also via the license manager GUI (Start > Intel(R) Software Development Products)

     Create license directory

1. Create a new license directory (recommended: Use the flexlm installation directory)
2. Copy all existing and new license files there (no need to edit and combine license files)
3. Have the license manager re-read the combined license file
        lmgrd lmreread –c <license_dir>
   On Windows you can re-read the new license also via the license manager GUI (Start > Intel(R) Software Development Products)

I need to add an Intel software license to an existing FlexNet/FlexNet Publisher license manager (lmgrd) already running for 3^rd party SW.
Same as above, but you need to make sure that the license manager lmgrd is of same or higher version as the Intel Vendor Daemon INTEL/INTEL.exe.

     Check for compatibility

1. Download and install the Intel license manager as described above
2. Run the Intel Vendor Daemon as follows:
        INTEL -v
3. Run the license manager as follows:
        lmgrd -v
   If the major and minor versions of lmgrd is the are the same or higher than the INTEL vendor daemon's versions you can use the existing license manager with the Intel Vendor Daemon. Otherwise you need to install an Intel License Manager in parallel to the existing license manager and run it on a different port.

     Add Intel Vendor Daemon to an existing license manager

1. Download the Intel license manager package as described above.
2. Extract downloaded package on a temp dir:
   Note: Under Windows you cannot change the installation directory. So in order to not overwrite an existing license manager installation, install it on another PC!
3. Take the Intel Vendor Daemon file INTEL / INTEL.exe and copy it to a directory on the license server (recommended: Use existing directory where the license manager lmgrd / lmgrd.exe) is running.
4. If required (i.e. if you copy the Intel vendor daemon not into the default directory) edit the license file and specify a path where the vendor daemon is located, for example
        VENDOR /flexlm/INTEL
   or
        VENDOR c:\Program Files (x86)\Common Files\Intel\LicenseServer\INTEL.exe
5. Combine licenses or create a new license directory as described above.
6. Restart the license manager as described above.

Setup Clients

There are several ways to setup a floating licensed product on client machine, but the most appropriate ones for an existing product installation or new / update installation on clients are the following.
Please note that this chapter applies to a single-license-server configuration only. Please refer to the Tips & Tricks section to use this method also for a redundant server configuration.

Product already exists on client
In this case you only need to create a new license file:

1. Use an editor and create a file with extension .lic with the following contents:
   SERVER <server_name|IP-address> <ANY|<server_MAC_address> <port>
   USE_SERVER
2. Copy the file to the default license directory:
   Linux:
   /opt/intel/licenses (for a (sudo)root installation)
   $HOME/intel/licenses (for a user installation)
   OS X:
   /Users/Shared/Library/Application Support/Intel/Licenses
   Windows:
   c:\Program Files (x86)\Common Files\Intel\Licenses\ (on 64-bit Windows systems)
   c:\Program Files\Common Files\Intel\Licenses\ (on 32-bit Windows systems)
3. Remove (or rename) all old or unused .lic files in the license directory

Update installation on client

1. Start the product installer

2. When it comes to product activation, the default activation option will be "Use Existing Activation"
   Select that option only if you are sure that the right server license was already set up with a previous installation. Otherwise select the following:
   Use "Alternative Activation > Use License Server" and specify the server name and port of the license server.

New product installation on client
 

1. Start the product installer
2. When it comes to product activation, the default activation option will be "Use Serial Number"
3. Do not use this option, but select "Alternative Activation > Use License Server" instead and specify the server name and port of the license server.
   CAVEAT! In complex environments this step may take long time (several minutes) until client-server connection and license verification/installation is finished.

Troubleshooting, Tips & Tricks
 

How to best setup a redundant server configuration

Setup of a redundant license server configuration remotely as described above is not supported by default, but you can perform the same steps as described above by referencing one of the servers only. After installation and server set up you can "expand" your client license by adding the other 2 servers in the client license, such as:

     SERVER <servername1> ANY <port>
     SERVER <servername2> ANY <port>
     SERVER <servername3> ANY <port>
     USE_SERVER

How to check license configuration from client

You can use the lmutil tool also on the client to perform the same license server checks as on the server.
Copy over the lmutil tool from the license server to the client or obtain it from FLEXERA's webpage (http://www.globes.com/support/fnp_utilities_download.htm).
Instead of using the license file or license directory use port@server as license parameter to invoke lmutil on the client, for example:
     lmutil lmstat -a -c <port>@<servername>
     lmutil lmdiag -c <port>@<servername>

How to check which license is being used

Linux only:
On Linux a very comfortable method is available to check which license and license server are being used. Create the enviornment variable FLEXLM_DIAGNOSTICS, assign it value 3 and invoke any of the tools icc, ifort, amplxe-cl, inpxe-cl or idbc, for example:

Linux/OS X:
Create the INTEL_LM_DEBUG enviornment variable, assing it a log file name and  invoke any of the tools icc, ifort, amplxe-cl, inpxe-cl or idbc. Search the logfile for any occurrence of the string SMSAxxxxxxxx. This 8-characters suffix is the serial number of the product that was used by invoking the product.For example:

Windows:
Open an Intel Software Development Product command prompt from the Start menu, create the INTEL_LM_DEBUG enviornment variable, assing it a log file name and  invoke any of the tools icl, ifort, amplxe-cl or inpxe-cl. Search the logfile for any occurrence of the string SMSAxxxxxxxx. This 8-characters suffix is the serial number of the product that was used by invoking the product.For example: 
      
       

Mixed Windows/Linux/OS X license server/client environment

You can run a single license server to manage a combined license for different client operating systems. The license server can run on Windows, Linux or OS X. In a heterogeneous environment it may be required to specify the full license server name including the full primary DNS suffix or the IP address in the license files of the clients.

Floating Licenses and Software License Manager Compatibility

In order to have full functionality of floating licensing service it is strongly recommended to use a license manager version that is specified for use with your product (please refer to the 'System Requirements' in the product release notes). Incompatible Intel license manager versions may result in reduced functionality when updating products on your client machines; for example they may not detect existing product activations or allow product activation via license server.

If you encounter problems updating products try one of the following workarounds:

• Upgrade Intel® Software License Manager to the newest version available on the Intel® Registration Center (choose the right OS and platform; only users with floating license registrations have access to this link).
• Use serial number (alphanumeric code of format xxxx-xxxxxxxx)
• Use license file (file extension .lic).

Note: Remote activation is not supported for floating licenses.

Disclaimer and Legal Information

INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL'S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT.
A "Mission Critical Application" is any application in which failure of the Intel Product could result, directly or indirectly, in personal injury or death. SHOULD YOU PURCHASE OR USE INTEL'S PRODUCTS FOR ANY SUCH MISSION CRITICAL APPLICATION, YOU SHALL INDEMNIFY AND HOLD INTEL AND ITS SUBSIDIARIES, SUBCONTRACTORS AND AFFILIATES, AND THE DIRECTORS, OFFICERS, AND EMPLOYEES OF EACH, HARMLESS AGAINST ALL CLAIMS COSTS, DAMAGES, AND EXPENSES AND REASONABLE ATTORNEYS' FEES ARISING OUT OF, DIRECTLY OR INDIRECTLY, ANY CLAIM OF PRODUCT LIABILITY, PERSONAL INJURY, OR DEATH ARISING IN ANY WAY OUT OF SUCH MISSION CRITICAL APPLICATION, WHETHER OR NOT INTEL OR ITS SUBCONTRACTOR WAS NEGLIGENT IN THE DESIGN, MANUFACTURE, OR WARNING OF THE INTEL PRODUCT OR ANY OF ITS PARTS.
Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.
The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request. Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order. Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or by visiting Intel's Web Site.
Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. See http://www.intel.com/products/processor_number for details.
Intel, Intel Atom, and Intel Core are trademarks of Intel Corporation in the U.S. and/or other countries.

* Other names and brands may be claimed as the property of others.
Java is a registered trademark of Oracle and/or its affiliates.
Copyright © 2013, Intel Corporation. All rights reserved.

Introduction

The purpose of this article is to show how we can easily integrate VTune™ Amplifier into Eclipse* by using the External tool configuration capability in Eclipse.  We will create several Eclipse external tool configurations for both launching collections and displaying collected data.

Overview

These are are the tool configurations we will be creating:

1. Local collection running for a duration of 5 seconds with results stored in Eclipse project.
2. Displaying collected results in the VTune Amplifier GUI.
3. Local collection launching an application created in an Eclipse project
4. Remote collection running on an embedded target for 5 seconds.

Details

External tool configuration #1 - Local collection running for a duration of 5 seconds with results stored in Eclipse project

Select Eclipse menu item Run->External Tools->External Tools Configurations…

This will bring up the External tool configuration dialog.

In our first configuration will be running a local advanced-hotspot collection for a duration of 5 seconds.

Click on the “New Item” icon.

• Name = amplxe-local
• Location is the local of the amplxe-cl executable in your file system. (/opt/intel/vtune_amplifier_xe_2013/bin64/amplxe-cl
• Arguments= -collect advanced-hotspot –r ${project_loc}/vtune_result@@@{at} –d 5

Once you have specified these values you can click apply to save. Then you can kick off a data collection by clicking Run.

Now that you have created a configuration you can kick off a run by using the menu item: Run->External Tools->amplxe-local.

This run will create a VTune Amplifier result directory in your project directory. 

External tool configuration #2 - Displaying collected results in the VTune Amplifier GUI

We can create a new External tool configuration to open this result using the VTune™ Amplifier GUI.

Select Eclipse menu item Run->External Tools->External Tools Configurations…

This will bring up the External tool configuration dialog.

Click on the “New Item” icon.

• Name = amplxe-gui-project
• Location is the file path of the amplxe-cl executable in your file system. (/opt/intel/vtune_amplifier_xe_2013/bin64/amplxe-gui
• Arguments=${resource_loc}

Click Apply, Then Click on the VTune Amplifier result directory in your project, the click Run. This will launch the VTune Amplifier GUI on the result directory you have selected.

External tool configuration #3 - Local collection launching an application created in a Eclipse project

For our next configuration we will reference an application that we built as part of the Eclipse/CDT. We will call this configuration amplxe-local1, in this case all of values will be the same as the configuration except we will not specify the –d 5 argument. Instead we will specify the location of the binary in the Eclipse project. To do this remove the –d 5 and click on the Variables button. Then scroll down to the resource_loc variable and click on it. Now if you click on Run->External Tool->amplxe-local1 it will launch a amplxe-cl run data collection with whatever executable you have selected in your project.

External tool configuration #4 - Remote collection running on an embedded target for 5 seconds

In our last tool configuration we will launch a remote amplxe-cl collection on an embedded target. Again, Specify the values as previously stated but instead of the Variable resource_loc, this time specify string_prompt.  Before the $string_prompt variable specify the following syntax. –target ssh:root@${string_prompt} as specified below:

.

Now when you click on Run->External Tool->amplxe-remote it will bring a dialog to prompt you for the target where you want to launch your collection.

Summary

We have shown 4 ways that VTune Amplifier can easily be integrated into Eclipse. There are many such integrations possible. VTune Amplifier has a very powerful command-line and GUI that can be used to make working with VTune Amplifier in Eclipse relatively seamless.