自学教程：C++ D2D1CreateFactory函数代码示例

/// <summary>/// Handle windows messages for the class instance/// </summary>/// <param name="hWnd">window message is for</param>/// <param name="uMsg">message</param>/// <param name="wParam">message data</param>/// <param name="lParam">additional message data</param>/// <returns>result of message processing</returns>LRESULT CALLBACK CBodyBasics::DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){    UNREFERENCED_PARAMETER(wParam);    UNREFERENCED_PARAMETER(lParam);    switch (message)    {    case WM_INITDIALOG:    {        // Bind application window handle        m_hWnd = hWnd;        // Init Direct2D        D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);        // Get and initialize the default Kinect sensor        InitializeDefaultSensor();    }    break;    // If the titlebar X is clicked, destroy app    case WM_CLOSE:        DestroyWindow(hWnd);        break;    case WM_DESTROY:        // Quit the main message pump        PostQuitMessage(0);        break;    }    return FALSE;}

BOOL DrawTimeFrequencyGrid::Initialize( float aFontSize ){	static const WCHAR msc_fontName[] = L"Verdana";	fontSize = aFontSize;	// Added code for factory here--odd place to put it.	HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory);	if ( FAILED(hr)) return FALSE;		// Create a DirectWrite factory.	hr = DWriteCreateFactory( DWRITE_FACTORY_TYPE_SHARED, __uuidof(pDWriteFactory),            reinterpret_cast<IUnknown **>(&pDWriteFactory) );	 if ( FAILED(hr)) return FALSE;	 // Create a DirectWrite text format object.     hr = pDWriteFactory->CreateTextFormat( msc_fontName, NULL,            DWRITE_FONT_WEIGHT_NORMAL,            DWRITE_FONT_STYLE_NORMAL,            DWRITE_FONT_STRETCH_NORMAL,            fontSize,            L"", //locale            &pTextFormat );	 if ( FAILED(hr)) return FALSE;	// Center the text horizontally and vertically.	pTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);	pTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);	return TRUE;}

nf_system_info_t nf_system_info(){	float ppi_x = 0.0f, ppi_y = 0.0f;	// instead of doing full initialization, let's just create a d2d1 factory	if(!ctx.reference_counter)	{		HRESULT hr = 0;		if(FAILED(hr = D2D1CreateFactory(						D2D1_FACTORY_TYPE_SINGLE_THREADED,						__uuidof(ID2D1Factory1),						NULL,						(void**)&ctx.d2d_factory)))		{			NF_ERROR("can't create d2d1 factory/n");			ctx.d2d_factory = NULL;		}	}	ctx.d2d_factory->GetDesktopDpi(&ppi_x, &ppi_y);	if(!ctx.reference_counter && ctx.d2d_factory)	{		ctx.d2d_factory->Release();		ctx.d2d_factory = NULL;	}	nf_system_info_t ret;	ret.bitmap = NF_BITMAP_B8G8R8A8_UNORM_PMA;	ret.max_width = NF_MAX_WIDTH;	ret.max_height = NF_MAX_HEIGHT;	ret.ppi_x = ppi_x;	ret.ppi_y = ppi_y;	return ret;}

LRESULT MainWindow::HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam){	switch (uMsg)	{	case WM_CREATE:		if (FAILED(D2D1CreateFactory(			D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory)))		{			return -1;  // Fail CreateWindowEx.		}		return 0;	case WM_DESTROY:		DiscardGraphicsResources();		SafeRelease(&pFactory);		PostQuitMessage(0);		return 0;	case WM_PAINT:		OnPaint();		return 0;	case WM_SIZE:		Resize();		return 0;	}	return DefWindowProc(m_hwnd, uMsg, wParam, lParam);}

void CDirect2D::init(){	std::cout << "Direct2D initialization: /n";	assert(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDirect2dFactory) == S_OK);	std::cout << "d2d1 factory created /n";	assert(m_hwnd);		RECT rc;	GetClientRect(m_hwnd, &rc);	HRESULT hr = m_pDirect2dFactory->CreateHwndRenderTarget(		D2D1::RenderTargetProperties(),		D2D1::HwndRenderTargetProperties(m_hwnd, D2D1::SizeU(rc.right - rc.left, rc.bottom - rc.top)),		&pRenderTarget);	//pRenderTarget->CreateSolidColorBrush(	//	D2D1::ColorF(D2D1::ColorF::Black),	//	&m_pBlackBrush);	//renderObj = new CRenderObject(L"test.png");	//renderObjectsList = new std::vector<CRenderObject *>;	//renderObjectsList.push_back(new CRenderObject(L"test.png"));		}

bool NND2DRenderer::Init(){	HRESULT hr;	hr = D2D1CreateFactory( D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_ipD2DFactory );	if ( hr != S_OK )	{		return false;	}	HWND hwnd = NNApplication::GetInstance()->GetHWND();	RECT rt;	GetClientRect( hwnd, &rt );	D2D1_SIZE_U size = D2D1::SizeU( rt.right-rt.left, rt.bottom-rt.top );	hr = m_ipD2DFactory->CreateHwndRenderTarget( D2D1::RenderTargetProperties(),												 D2D1::HwndRenderTargetProperties( hwnd, size ),												 &m_ipRenderTarget );	if ( hr != S_OK )	{		return false;	}	return true;}

//// Program starts here//int main( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow ){	HRESULT hr = D2D1CreateFactory(					 D2D1_FACTORY_TYPE_SINGLE_THREADED,					 &g_pD2DFactory				 );	hr = DWriteCreateFactory(			 DWRITE_FACTORY_TYPE_SHARED,			 __uuidof( IDWriteFactory ),			 reinterpret_cast<IUnknown**>( &g_pDWriteFactory )		 );	hr = CoInitialize( NULL );	hr = CoCreateInstance(			 CLSID_WICImagingFactory,			 NULL,			 CLSCTX_INPROC_SERVER,			 IID_IWICImagingFactory,			 reinterpret_cast<void**>( &g_pWICFactory )		 );	g_pHWND = CreateGameWindow();	createDeviceResources();	//	// Create a GWEN Direct2D renderer	//	g_pRenderer = new gwen::Renderer::Direct2D( g_pRT, g_pDWriteFactory, g_pWICFactory );	runSample();	delete g_pRenderer;	g_pRenderer = NULL;	if ( g_pRT != NULL )	{		g_pRT->Release();		g_pRT = NULL;	}}

    Direct2DRendererPrivate():        VideoRendererPrivate()      , d2d_factory(0)      , render_target(0)      , bitmap(0)      , bitmap_width(0)      , bitmap_height(0)      , interpolation(D2D1_BITMAP_INTERPOLATION_MODE_LINEAR)    {        dll.setFileName(QStringLiteral("d2d1"));        if (!dll.load()) {            available = false;            qWarning("Direct2D is disabled. Failed to load 'd2d1.dll': %s", dll.errorString().toUtf8().constData());            return;        }        typedef HRESULT (WINAPI *D2D1CreateFactory_t)(D2D1_FACTORY_TYPE, REFIID, const D2D1_FACTORY_OPTIONS *, void **ppIFactory);        D2D1CreateFactory_t D2D1CreateFactory;        D2D1CreateFactory = (D2D1CreateFactory_t)dll.resolve("D2D1CreateFactory");        if (!D2D1CreateFactory) {            available = false;            qWarning("Direct2D is disabled. Failed to resolve symble 'D2D1CreateFactory': %s", dll.errorString().toUtf8().constData());            return;        }        D2D1_FACTORY_OPTIONS factory_opt = { D2D1_DEBUG_LEVEL_NONE };        /*         * d2d is accessed by AVThread and GUI thread, so we use D2D1_FACTORY_TYPE_MULTI_THREADED         * and let d2d to deal with the thread safe problems. otherwise, if we use         * D2D1_FACTORY_TYPE_SINGLE_THREADED, we must use lock when copying ID2D1Bitmap and calling EndDraw.         */        /// http://msdn.microsoft.com/en-us/library/windows/desktop/dd368104%28v=vs.85%29.aspx        HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED                                       , (REFIID)IID_ID2D1Factory                                       , &factory_opt                                       , (void**)&d2d_factory);        if (FAILED(hr)) {            available = false;            qWarning("Direct2D is disabled. Create d2d factory failed");            return;        }        FLOAT dpiX, dpiY;        d2d_factory->GetDesktopDpi(&dpiX, &dpiY);        //gcc: extended initializer lists only available with -std=c++11 or -std=gnu++11        //vc: http://msdn.microsoft.com/zh-cn/library/t8xe60cf(v=vs.80).aspx        /*pixel_format = {            DXGI_FORMAT_B8G8R8A8_UNORM,            D2D1_ALPHA_MODE_IGNORE        };*/        pixel_format.format = DXGI_FORMAT_B8G8R8A8_UNORM;        pixel_format.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;//D2D1_ALPHA_MODE_IGNORE;        /*bitmap_properties = {            pixel_format,            dpiX,            dpiY        };*/        bitmap_properties.pixelFormat = pixel_format;        bitmap_properties.dpiX = dpiX;        bitmap_properties.dpiY = dpiY;    }

HRESULT CRMrender::CreateFactory(){	HRESULT hr = S_FALSE;	hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDisplayFactory);	return hr;}

HRESULT MainApp::CreateDeviceIndependentResources(){	HRESULT hr = S_OK;	hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pDirect2dFactory);	return hr;}

// Creates resources that are not bound to a particular device.// Their lifetime effectively extends for the duration of the// application.HRESULT DemoApp::CreateDeviceIndependentResources(){    HRESULT hr = S_OK;    // Create a Direct2D factory.    hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDirect2dFactory);    return hr;}

  void seq_tab_dialog::create_device_independent_resources()  {    // Direct2DFactory の生成    if(!d2d_factory_){#if defined(DEBUG) || defined(_DEBUG)      D2D1_FACTORY_OPTIONS options;      options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION ;      THROW_IFERR(D2D1CreateFactory(        D2D1_FACTORY_TYPE_SINGLE_THREADED,        options,        d2d_factory_.GetAddressOf()        ));#else      THROW_IFERR(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &d2d_factory_));#endif    }    if(!write_factory_){      THROW_IFERR(::DWriteCreateFactory(        DWRITE_FACTORY_TYPE_SHARED,        __uuidof(IDWriteFactory),        reinterpret_cast<IUnknown**>(write_factory_.GetAddressOf())        ));    }    //wic_imaging_factory_.CreateInstance(CLSID_WICImagingFactory);    //thunk_proc_ = (WNDPROC)thunk_.getCode();    layout_rect_ = D2D1::RectF(0.0f,100.0f,400.0f,100.0f);    // Text Formatの作成    THROW_IFERR(write_factory_->CreateTextFormat(      L"MS GOTHIC",                // Font family name.      NULL,                       // Font collection (NULL sets it to use the system font collection).      DWRITE_FONT_WEIGHT_BOLD,      DWRITE_FONT_STYLE_NORMAL,      DWRITE_FONT_STRETCH_NORMAL,      12.0f,      L"ja-jp",      &write_text_format_      ));  }

/// <summary>/// Handle windows messages for the class instance/// </summary>/// <param name="hWnd">window message is for</param>/// <param name="uMsg">message</param>/// <param name="wParam">message data</param>/// <param name="lParam">additional message data</param>/// <returns>result of message processing</returns>LRESULT CALLBACK Direct2DWindow::DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){    switch (message)    {        case WM_INITDIALOG:        {            // Bind application window handle            m_hWnd = hWnd;            // Init Direct2D            D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);            // Create and initialize a new Direct2D image renderer (take a look at ImageRenderer.h)            // We'll use this to draw the data we receive from the Kinect to the screen            m_pDrawDepth = new ImageRenderer();            HRESULT hr = m_pDrawDepth->Initialize(GetDlgItem(m_hWnd, IDC_VIDEOVIEW),                                                  m_pD2DFactory,                                                  m_cdmap->GetFieldWidth(),                                                  m_cdmap->GetFieldHeight(),                                                  m_cdmap->GetFieldWidth() * sizeof(long));            if (FAILED(hr))            {                SetStatusMessage(L"Failed to initialize the Direct2D draw device.");            }        }        break;        // If the titlebar X is clicked, destroy app        case WM_CLOSE:            DestroyWindow(hWnd);            break;        case WM_DESTROY:            // Quit the main message pump            PostQuitMessage(0);            break;        // Handle button press        case WM_COMMAND:            // If it was for the near mode control and a clicked event, change near mode            if (IDC_CHECK_NEARMODE == LOWORD(wParam) && BN_CLICKED == HIWORD(wParam))            {                // Toggle out internal state for near mode                //m_bNearMode = !m_bNearMode;                //if (NULL != m_pNuiSensor)                //{                //    // Set near mode based on our internal state                //    m_pNuiSensor->NuiImageStreamSetImageFrameFlags(m_pDepthStreamHandle, m_bNearMode ? NUI_IMAGE_STREAM_FLAG_ENABLE_NEAR_MODE : 0);                //}            }            break;    }    return FALSE;}

    SharedD2DFactory()    {        jassertfalse; //xxx Direct2D support isn't ready for use yet!        D2D1CreateFactory (D2D1_FACTORY_TYPE_SINGLE_THREADED, d2dFactory.resetAndGetPointerAddress());        DWriteCreateFactory (DWRITE_FACTORY_TYPE_SHARED, __uuidof (IDWriteFactory), (IUnknown**) directWriteFactory.resetAndGetPointerAddress());        if (directWriteFactory != nullptr)            directWriteFactory->GetSystemFontCollection (systemFonts.resetAndGetPointerAddress());    }

HRESULT App::CreateDeviceIndependentResources(){	HRESULT hr;	// Create a Direct2D factory.#if defined(DEBUG) || defined(_DEBUG)	D2D1_FACTORY_OPTIONS options;	options.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;	hr = D2D1CreateFactory(		D2D1_FACTORY_TYPE_SINGLE_THREADED,		options,		&D2D_Factory		);#else	hr = D2D1CreateFactory(		D2D1_FACTORY_TYPE_MULTI_THREADED,		&D2D_Factory		);#endif	if (SUCCEEDED(hr))	{		// Create WIC factory.		hr = CoCreateInstance(			CLSID_WICImagingFactory,			NULL,			CLSCTX_INPROC_SERVER,			IID_PPV_ARGS(&WIC_Factory)			);	}	if (SUCCEEDED(hr))	{		// Create a DirectWrite factory.		hr = DWriteCreateFactory(			DWRITE_FACTORY_TYPE_SHARED,			__uuidof(DW_Factory),			reinterpret_cast<IUnknown **>(&DW_Factory)			);	}    return hr;}

VOID CreateD2DResource(HWND hWnd){	if (!g_pRenderTarget)	{		HRESULT hr ;		hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &g_pD2DFactory) ;		if (FAILED(hr))		{			MessageBox(hWnd, "Create D2D factory failed!", "Error", 0) ;			return ;		}		// Obtain the size of the drawing area		RECT rc ;		GetClientRect(hWnd, &rc) ;		// Create a Direct2D render target		hr = g_pD2DFactory->CreateHwndRenderTarget(			D2D1::RenderTargetProperties(),			D2D1::HwndRenderTargetProperties(			hWnd, 			D2D1::SizeU(rc.right - rc.left,rc.bottom - rc.top)			), 			&g_pRenderTarget			) ;		if (FAILED(hr))		{			MessageBox(hWnd, "Create render target failed!", "Error", 0) ;			return ;		}		// Create a brush		hr = g_pRenderTarget->CreateSolidColorBrush(			D2D1::ColorF(D2D1::ColorF::Black),			&g_pBlackBrush			) ;		if (FAILED(hr))		{			MessageBox(hWnd, "Create brush failed!", "Error", 0) ;			return ;		}		// Create a rectangle		hr = g_pD2DFactory->CreateRectangleGeometry(			D2D1::RectF(10, 10, 50, 50),			&g_pRectangleGeometry			);		if (FAILED(hr))		{			MessageBox(hWnd, "Create rectangle geometry failed!", "Error", 0);			return;		}	}}

HRESULT CMainWindow::CreateDeviceIndependentResources(){    // Create a Direct2D factory        HRESULT hr = D2D1CreateFactory(        D2D1_FACTORY_TYPE_SINGLE_THREADED,        &m_pD2DFactory        );    return hr;}

	void Factory::Init( FactoryType factoryType, DebugLevel debugLevel )	{		ID2D1Factory *factory = NULL;		D2D1_FACTORY_OPTIONS options;		options.debugLevel = static_cast<D2D1_DEBUG_LEVEL>( debugLevel );		if( RECORD_D2D( D2D1CreateFactory( static_cast<D2D1_FACTORY_TYPE>( factoryType ), IID_ID2D1Factory, &options, (void**) &factory ) ).IsFailure )			throw gcnew Direct2DException( Result::Last );		Construct( factory );	}

HRESULT initDraw(void){	D2D1_FACTORY_OPTIONS opts;	ZeroMemory(&opts, sizeof (D2D1_FACTORY_OPTIONS));	// TODO make this an option	opts.debugLevel = D2D1_DEBUG_LEVEL_NONE;	return D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,		&IID_ID2D1Factory,		&opts,		(void **) (&d2dfactory));}

bool Graphics::InitGraphics(HWND hwnd){	HRESULT res = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &factory);	if (res != S_OK)		return false;	RECT rect;	GetClientRect(hwnd, &rect);	res = factory->CreateHwndRenderTarget(D2D1::RenderTargetProperties(), D2D1::HwndRenderTargetProperties(hwnd, D2D1::SizeU(rect.right, rect.bottom)), &renderTarget);	if (res != S_OK)		return false;	return true;}

HRESULT FirstTry::CreateDeviceIndependentResources(){	HRESULT hr = S_OK;		// Create a Direct2D factory.	hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);	if (SUCCEEDED(hr))		hr = CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&m_pWICFactory));	return hr;}

/// <summary>/// Ensure the independent Direct2D resources have been created/// </summary>void EnsureIndependentResourcesCreated(){    if (nullptr == g_pD2DFactory)    {        D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED, &g_pD2DFactory);    }    if (nullptr == g_pDWriteFactory)    {        DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), reinterpret_cast<IUnknown**>(&g_pDWriteFactory));    }}

plx::ComPtr<ID2D1Factory2> CreateD2D1FactoryST(D2D1_DEBUG_LEVEL debug_level) {  D2D1_FACTORY_OPTIONS options = {};  options.debugLevel = debug_level;  plx::ComPtr<ID2D1Factory2> factory;  auto hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,                              options,                              factory.GetAddressOf());  if (hr != S_OK)    throw plx::ComException(__LINE__, hr);  return factory;}

inline ComPtr<ID2D1Factory1> CreateD2DFactory(){	D2D1_FACTORY_OPTIONS fo{};#ifdef DEBUG	fo.debugLevel = D2D1_DEBUG_LEVEL_INFORMATION;#endif	ComPtr<ID2D1Factory1> d2dFactory;	HR(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, fo, d2dFactory.GetAddressOf()));	return d2dFactory;}

/// <summary>/// Handle windows messages for the class instance/// </summary>/// <param name="hWnd">window message is for</param>/// <param name="uMsg">message</param>/// <param name="wParam">message data</param>/// <param name="lParam">additional message data</param>/// <returns>result of message processing</returns>LRESULT CALLBACK CCoordinateMappingBasics::DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){    UNREFERENCED_PARAMETER(wParam);    UNREFERENCED_PARAMETER(lParam);    switch (message)    {        case WM_INITDIALOG:        {            // Bind application window handle            m_hWnd = hWnd;            // Init Direct2D            D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);            // Create and initialize a new Direct2D image renderer (take a look at ImageRenderer.h)            // We'll use this to draw the data we receive from the Kinect to the screen            m_pDrawCoordinateMapping = new ImageRenderer();             HRESULT hr = m_pDrawCoordinateMapping->Initialize(GetDlgItem(m_hWnd, IDC_VIDEOVIEW), m_pD2DFactory, cDepthWidth, cDepthHeight, cDepthWidth * sizeof(RGBQUAD));             if (FAILED(hr))            {                SetStatusMessage(L"Failed to initialize the Direct2D draw device.", 10000, true);            }            // Get and initialize the default Kinect sensor            InitializeDefaultSensor();        }        break;        // If the titlebar X is clicked, destroy app        case WM_CLOSE:            DestroyWindow(hWnd);            break;        case WM_DESTROY:            // Quit the main message pump            PostQuitMessage(0);            break;        // Handle button press        case WM_COMMAND:            // If it was for the screenshot control and a button clicked event, save a screenshot next frame             if (IDC_BUTTON_SCREENSHOT == LOWORD(wParam) && BN_CLICKED == HIWORD(wParam))            {                m_bSaveScreenshot = true;            }            break;    }    return FALSE;}

HRESULT ClixRenderer::CreateDIR(){	HRESULT hr = S_OK;	hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &D2Factory);	if (SUCCEEDED(hr))	{		hr = DWriteCreateFactory(			DWRITE_FACTORY_TYPE_SHARED,			__uuidof(IDWriteFactory),			reinterpret_cast<IUnknown**>(&pDWriteFactory)			);	}	if (SUCCEEDED(hr))	{		hr = pDWriteFactory->CreateTextFormat(			L"Microsoft Sans Serif Regular",                // Font family name.			NULL,                       // Font collection (NULL sets it to use the system font collection).			DWRITE_FONT_WEIGHT_REGULAR,			DWRITE_FONT_STYLE_NORMAL,			DWRITE_FONT_STRETCH_NORMAL,			15.0f,			L"en-us",			&pTextFormat			);	}	// Center align (horizontally) the text.	if (SUCCEEDED(hr))	{		hr = pTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_LEADING);	}	if (SUCCEEDED(hr))	{		hr = pTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);	}#ifdef CONSOLE	if (SUCCEEDED(hr))		std::wcout << "DeviceIndependendResources Succesfully created!" << std::endl;	else		std::wcout << "DeviceIndependedResources Error: " << std::hex << hr << std::endl;#endif	return hr;}

HRESULT CAshaD2D::CreateFactory(void){	HRESULT hr=S_OK;	//Initialize com	CoInitializeEx(NULL,COINIT_MULTITHREADED);	//Create WIC factory	hr=CoCreateInstance(CLSID_WICImagingFactory1,NULL,CLSCTX_INPROC_SERVER,IID_PPV_ARGS(&m_pWICImgFactory));	//Create D2D factory	if(SUCCEEDED(hr))		hr=D2D1CreateFactory(D2D1_FACTORY_TYPE_MULTI_THREADED,&m_pD2D1Facatory);	//Create DWrite factory	if(SUCCEEDED(hr))		hr=DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED,__uuidof(IDWriteFactory),reinterpret_cast<IUnknown**>(&m_pDWriteFactory));	return hr;}

BOOL ResonanceStudioDraw::PreCreateWindow(CREATESTRUCT& cs){    // TODO: Modify the Window class or styles here by modifying    //  the CREATESTRUCT cs    // Added code for factory here--odd place to put it.    HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &pFactory);    if ( FAILED(hr)) return FALSE;    ptheDrawTimeFrequencyGrid = new DrawTimeFrequencyGrid();    if ( !ptheDrawTimeFrequencyGrid->Initialize( 10.0 ) )        return FALSE;    return TRUE;}

	opengl_window::opengl_window(i_rendering_engine& aRenderingEngine, i_surface_manager& aSurfaceManager, i_native_window_event_handler& aEventHandler) :		native_window(aRenderingEngine, aSurfaceManager),		iEventHandler(aEventHandler),		iLogicalCoordinateSystem(neogfx::logical_coordinate_system::AutomaticGui),		iFrameRate(60),		iFrameCounter(0),		iLastFrameTime(0),		iRendering(false)	{#ifdef _WIN32		ID2D1Factory* m_pDirect2dFactory;		D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDirect2dFactory);		FLOAT dpiX, dpiY;		m_pDirect2dFactory->GetDesktopDpi(&dpiX, &dpiY);		iPixelDensityDpi = size(static_cast<size::dimension_type>(dpiX), static_cast<size::dimension_type>(dpiY));#endif	}

/// <summary>/// Handle windows messages for the class instance/// </summary>/// <param name="hWnd">window message is for</param>/// <param name="uMsg">message</param>/// <param name="wParam">message data</param>/// <param name="lParam">additional message data</param>/// <returns>result of message processing</returns>LRESULT CALLBACK CSkeletonBasics::DlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam){    switch (message)    {        case WM_INITDIALOG:        {            // Bind application window handle            m_hWnd = hWnd;            // Init Direct2D            D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pD2DFactory);            // Look for a connected Kinect, and create it if found            CreateFirstConnected();        }        break;        // If the titlebar X is clicked, destroy app        case WM_CLOSE:            DestroyWindow(hWnd);            break;        case WM_DESTROY:            // Quit the main message pump            PostQuitMessage(0);            break;        // Handle button press        case WM_COMMAND:            // If it was for the near mode control and a clicked event, change near mode            if (IDC_CHECK_SEATED == LOWORD(wParam) && BN_CLICKED == HIWORD(wParam))            {                // Toggle out internal state for near mode                m_bSeatedMode = !m_bSeatedMode;                if (NULL != m_pNuiSensor)                {                    // Set near mode for sensor based on our internal state                    m_pNuiSensor->NuiSkeletonTrackingEnable(m_hNextSkeletonEvent, m_bSeatedMode ? NUI_SKELETON_TRACKING_FLAG_ENABLE_SEATED_SUPPORT : 0);                }            }            break;    }    return FALSE;}