Exemplo n.º 1
0
//-----------------------------------------------------------------------------
void D2DDrawContext::createRenderTarget ()
{
    if (window)
    {
        RECT rc;
        GetClientRect (window, &rc);

        D2D1_SIZE_U size = D2D1::SizeU (rc.right - rc.left, rc.bottom - rc.top);
        ID2D1HwndRenderTarget* hwndRenderTarget = 0;
//		D2D1_RENDER_TARGET_TYPE targetType = D2D1_RENDER_TARGET_TYPE_DEFAULT;
        D2D1_RENDER_TARGET_TYPE targetType = D2D1_RENDER_TARGET_TYPE_SOFTWARE;
        D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat (DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED);
        HRESULT hr = getD2DFactory ()->CreateHwndRenderTarget (D2D1::RenderTargetProperties (targetType, pixelFormat), D2D1::HwndRenderTargetProperties (window, size, D2D1_PRESENT_OPTIONS_RETAIN_CONTENTS), &hwndRenderTarget);
        if (SUCCEEDED (hr))
        {
            hwndRenderTarget->SetDpi (96.0, 96.0);
            renderTarget = hwndRenderTarget;
        }
    }
    else if (bitmap)
    {
        D2DBitmap* d2dBitmap = dynamic_cast<D2DBitmap*> (bitmap->getPlatformBitmap ());
        if (d2dBitmap)
        {
            D2D1_RENDER_TARGET_TYPE targetType = D2D1_RENDER_TARGET_TYPE_SOFTWARE;
            D2D1_PIXEL_FORMAT pixelFormat = D2D1::PixelFormat (DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED);
            HRESULT hr = getD2DFactory ()->CreateWicBitmapRenderTarget (d2dBitmap->getBitmap (), D2D1::RenderTargetProperties (targetType, pixelFormat), &renderTarget);
        }
    }
    init ();
}
Exemplo n.º 2
0
void CSprite::Draw(const sRect& src, const sRect& dest)
{
	ID2D1HwndRenderTarget* prt = g_Graphics.GetRenderTarget();
	if (!prt) return;


	D2D1_RECT_F destx = D2D1::RectF(dest.left, dest.top, dest.right, dest.bottom),
				srcx = D2D1::RectF(src.left, src.top, src.right, src.bottom);

	prt->DrawBitmap(m_pBitmap, destx, m_fOpacity, D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR, srcx);
}
Exemplo n.º 3
0
LRESULT CALLBACK wndproc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	LONG_PTR userdata;
	ID2D1HwndRenderTarget *rt = NULL;
	WINDOWPOS *wp = (WINDOWPOS *) lParam;
	RECT client;
	D2D1_SIZE_U size;

	userdata = GetWindowLongPtrW(hwnd, GWLP_USERDATA);
	if (userdata == 0) {
		if (uMsg == WM_CREATE)
			SetWindowLongPtrW(hwnd, GWLP_USERDATA, 1);
		return DefWindowProcW(hwnd, uMsg, wParam, lParam);
	}

	if (userdata == 1) {
		rt = mkRenderTarget(hwnd);
		if (rt == NULL) {
			PostQuitMessage(1);
			return DefWindowProcW(hwnd, uMsg, wParam, lParam);
		}
		SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR) rt);
	} else
		rt = (ID2D1HwndRenderTarget *) userdata;

	switch (uMsg) {
	case WM_PAINT:
		switch (doPaint(rt)) {
		case S_OK:
			ValidateRect(hwnd, NULL);
			return 0;
		case D2DERR_RECREATE_TARGET:
			rt->Release();
			SetWindowLongPtrW(hwnd, GWLP_USERDATA, 1);
			return 0;
		}
		rt->Release();
		PostQuitMessage(1);
		break;
	case WM_WINDOWPOSCHANGED:
		if ((wp->flags & SWP_NOSIZE) != 0)
			break;
		GetClientRect(hwnd, &client);
		size.width = client.right - client.left;
		size.height = client.bottom - client.top;
		rt->Resize(&size);
		InvalidateRect(hwnd, NULL, TRUE);
		return 0;
	case WM_CLOSE:
		rt->Release();
		PostQuitMessage(0);
	}
	return DefWindowProcW(hwnd, uMsg, wParam, lParam);
}
Exemplo n.º 4
0
HRESULT MainWindow::CreateGraphicsResources()
{
	HRESULT hr = S_OK;
	if (pRenderTarget == NULL)
	{
		RECT rc;
		GetClientRect(m_hwnd, &rc);

		D2D1_SIZE_U size = D2D1::SizeU(rc.right, rc.bottom);

		hr = pFactory->CreateHwndRenderTarget(
			D2D1::RenderTargetProperties(),
			D2D1::HwndRenderTargetProperties(m_hwnd, size),
			&pRenderTarget);

		if (SUCCEEDED(hr))
		{
			const D2D1_COLOR_F color = D2D1::ColorF(1.0f, 1.0f, 0);
			hr = pRenderTarget->CreateSolidColorBrush(color, &pBrush);

			if (SUCCEEDED(hr))
			{
				CalculateLayout();
			}
		}
	}
	return hr;
}
Exemplo n.º 5
0
void MWinDeviceImpl::Save()
{
	ID2D1DrawingStateBlock* state;
	THROW_IF_HRESULT_ERROR(sD2DFactory->CreateDrawingStateBlock(&state));
	mRenderTarget->SaveDrawingState(state);
	mState.push(state);
}
Exemplo n.º 6
0
void MWinDeviceImpl::ClipRect(
	MRect				inRect)
{
	if (mClipLayer != nil)
	{
		mRenderTarget->PopLayer();
		mClipLayer->Release();
	}

	THROW_IF_HRESULT_ERROR(mRenderTarget->CreateLayer(&mClipLayer));

    // Push the layer with the geometric mask.
	mRenderTarget->PushLayer(
		D2D1::LayerParameters(D2D1::RectF(inRect.x, inRect.y,
			inRect.x + inRect.width, inRect.y + inRect.height)),
		mClipLayer);
}
Exemplo n.º 7
0
void MWinDeviceImpl::CreateAndUsePattern(
	MColor				inColor1,
	MColor				inColor2)
{
	uint32 data[8][8];

	uint32 c1 = 0, c2 = 0;

	c1 |= inColor1.red << 16;
	c1 |= inColor1.green << 8;
	c1 |= inColor1.blue << 0;
	
	c2 |= inColor2.red << 16;
	c2 |= inColor2.green << 8;
	c2 |= inColor2.blue << 0;

	for (uint32 y = 0; y < 8; ++y)
	{
		for (uint32 x = 0; x < 4; ++x)
			data[y][x] = c1;
		for (uint32 x = 4; x < 8; ++x)
			data[y][x] = c2;
	}

	ID2D1BitmapBrush* brush;

	ID2D1Bitmap* bitmap;
	THROW_IF_HRESULT_ERROR(mRenderTarget->CreateBitmap(D2D1::SizeU(8, 8), data, 32,
		D2D1::BitmapProperties(
			D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE)
		), &bitmap));

	THROW_IF_HRESULT_ERROR(mRenderTarget->CreateBitmapBrush(
		bitmap,
		D2D1::BitmapBrushProperties(D2D1_EXTEND_MODE_WRAP, D2D1_EXTEND_MODE_WRAP),
		D2D1::BrushProperties(1.0f, D2D1::Matrix3x2F::Rotation(45.f)),
		&brush));

	bitmap->Release();

	if (mForeBrush != nil)
		mForeBrush->Release();

	mForeBrush = brush;
}
Exemplo n.º 8
0
void MWinDeviceImpl::FillRect(
	MRect				inRect)
{
	assert(mForeBrush);
	assert(mRenderTarget);

	mRenderTarget->FillRectangle(
		D2D1::RectF(inRect.x, inRect.y, inRect.x + inRect.width, inRect.y + inRect.height), mForeBrush);
}
Exemplo n.º 9
0
void LetterHunter::render(float timeDelta)
{
	// Create device dependent resources
	d2d_->createDeviceResources(hwnd_);

	// Get Hwnd render target
	ID2D1HwndRenderTarget* rendertarget = d2d_->getD2DHwndRenderTarget();

	// Update text object before rendering
	update(timeDelta);

	rendertarget->BeginDraw();

	// Set render target background color to white
	rendertarget->Clear(D2D1::ColorF(D2D1::ColorF::White));

	// render background image
	wchar_t*	imageFile = L"./Media/Picture/Fairy_of_the_Water.jpg";
	drawBackgroundImage(imageFile);

	// render text objects
	for(unsigned int i = 0; i < textBuffer_.size(); ++i)
	{
		if(textBuffer_[i]->isLive())
		{
			textBuffer_[i]->render();
		}
	}

	// render bullet objects
	for(unsigned int i = 0; i < bulletBuffer_.size(); ++i)
	{
		if(bulletBuffer_[i]->isLive())
		{
			bulletBuffer_[i]->render();
		}
	}

	// render score
	score_->draw();

	rendertarget->EndDraw();
}
Exemplo n.º 10
0
void MWinDeviceImpl::StrokeRect(
	MRect				inRect,
	uint32				inLineWidth)
{
	assert(mForeBrush);
	assert(mRenderTarget);

	mRenderTarget->DrawRectangle(
		D2D1::RectF(inRect.x, inRect.y, inRect.x + inRect.width, inRect.y + inRect.height), mForeBrush);
}
Exemplo n.º 11
0
void MainWindow::CalculateLayout()
{
	if (pRenderTarget != NULL)
	{
		D2D1_SIZE_F size = pRenderTarget->GetSize();
		const float x = size.width / 2;
		const float y = size.height / 2;
		const float radius = min(x, y);
		ellipse = D2D1::Ellipse(D2D1::Point2F(x, y), radius, radius);
	}
}
Exemplo n.º 12
0
void MainWindow::OnPaint()
{
	HRESULT hr = CreateGraphicsResources();
	if (SUCCEEDED(hr))
	{
		PAINTSTRUCT ps;
		BeginPaint(m_hwnd, &ps);

		pRenderTarget->BeginDraw();

		pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::SkyBlue));
		pRenderTarget->FillEllipse(ellipse, pBrush);

		hr = pRenderTarget->EndDraw();
		if (FAILED(hr) || hr == D2DERR_RECREATE_TARGET)
		{
			DiscardGraphicsResources();
		}
		EndPaint(m_hwnd, &ps);
	}
}
Exemplo n.º 13
0
void MWinDeviceImpl::SetBackColor(
	MColor				inColor)
{
	if (mBackBrush != nil)
		mBackBrush->Release();

	ID2D1SolidColorBrush* brush;
	THROW_IF_HRESULT_ERROR(
		mRenderTarget->CreateSolidColorBrush(D2D1::ColorF(inColor.red / 255.f, inColor.green / 255.f, inColor.blue / 255.f), &brush));

	mBackBrush = brush;
}
Exemplo n.º 14
0
// ----------------------------------------------------------------
//	LoadResource
// ----------------------------------------------------------------
bool CD2DBitmap::LoadResource( ResourceId id )
{
	ID2D1HwndRenderTarget * renderTarget = CD2DRenderer::GetInstance().GetHwndRenderTarget();
	IWICImagingFactory * imagingFactory = CD2DRenderer::GetInstance().GetImagingFactory();

	IWICBitmapDecoder * bitmapDecoder = nullptr;
	IWICBitmapFrameDecode* bitmapFrameDecode = nullptr;

	imagingFactory->CreateDecoderFromFilename( id.c_str(), nullptr, GENERIC_READ, WICDecodeMetadataCacheOnDemand, &bitmapDecoder );
	bitmapDecoder->GetFrame( 0, &bitmapFrameDecode );

	imagingFactory->CreateFormatConverter( &m_FmtConverter );
	m_FmtConverter->Initialize( bitmapFrameDecode, GUID_WICPixelFormat32bppPBGRA, WICBitmapDitherTypeNone, nullptr, 0.0f, WICBitmapPaletteTypeCustom );

	renderTarget->CreateBitmapFromWicBitmap( m_FmtConverter, nullptr, &m_D2DBitmap );

	SafeRelease( bitmapDecoder );
	SafeRelease( bitmapFrameDecode );

	return true;
}
Exemplo n.º 15
0
void MWinDeviceImpl::DrawString(
	const string&		inText,
	float				inX,
	float				inY,
	uint32				inTruncateWidth,
	MAlignment			inAlign)
{
	wstring s(c2w(inText));
	mRenderTarget->DrawTextW(s.c_str(), s.length(),
		GetTextFormat(),
		D2D1::RectF(inX, inY, 200, 14),
		mForeBrush);
}
Exemplo n.º 16
0
void MainWindow::Resize()
{
	if (pRenderTarget != NULL)
	{
		RECT rc;
		GetClientRect(m_hwnd, &rc);

		D2D1_SIZE_U size = D2D1::SizeU(rc.right, rc.bottom);

		pRenderTarget->Resize(size);
		CalculateLayout();
		InvalidateRect(m_hwnd, NULL, FALSE);
	}
}
Exemplo n.º 17
0
void MWinDeviceImpl::FillEllipse(
	MRect				inRect)
{
	assert(mForeBrush);
	assert(mRenderTarget);

	float radius;
	if (inRect.height < inRect.width)
		radius = inRect.height / 2.f;
	else
		radius = inRect.width / 2.f;

	D2D1_ROUNDED_RECT r =
		D2D1::RoundedRect(D2D1::RectF(inRect.x, inRect.y, inRect.x + inRect.width, inRect.y + inRect.height),
		radius, radius);

	mRenderTarget->FillRoundedRectangle(r, mForeBrush);
}
Exemplo n.º 18
0
void MWinDeviceImpl::SetOrigin(
	int32		inX,
	int32		inY)
{
	mRenderTarget->SetTransform(D2D1::Matrix3x2F::Translation(inX, inY));
}
Exemplo n.º 19
0
HRESULT D2DRenderer::InitializeDeviceDependentResources()
{
    HRESULT hr = S_OK;

    if (renderTarget_ != NULL)
        return hr;

    ID2D1HwndRenderTarget* renderTarget = NULL;
    ID2D1SolidColorBrush*  backBrush    = NULL;
    ID2D1SolidColorBrush*  textBrush    = NULL;
    ID2D1SolidColorBrush*  borderBrush  = NULL;

    D2D1_RENDER_TARGET_PROPERTIES renderTargetProperties = D2D1::RenderTargetProperties(
        D2D1_RENDER_TARGET_TYPE_DEFAULT,
        D2D1::PixelFormat(),
        static_cast<float>(g_dpiX),
        static_cast<float>(g_dpiY)
        );

    if (SUCCEEDED(hr))
    {
        hr = g_d2dFactory->CreateHwndRenderTarget(
                renderTargetProperties,
                D2D1::HwndRenderTargetProperties(hwnd_, D2D1::SizeU(width_, height_)),
                &renderTarget
                );
    }

    if (renderingParams_ != NULL)
    {
        renderTarget->SetTextRenderingParams(renderingParams_);
    }

    backColor_ = D2D1::ColorF(GetSysColor(COLOR_WINDOW));

    if (SUCCEEDED(hr))
    {
        hr = renderTarget->CreateSolidColorBrush(
                backColor_,
                &backBrush
                );
    }

    if (SUCCEEDED(hr))
    {
        hr = renderTarget->CreateSolidColorBrush(
                D2D1::ColorF(GetSysColor(COLOR_WINDOWTEXT)),
                &textBrush
                );
    }

    if (SUCCEEDED(hr))
    {
        hr = renderTarget->CreateSolidColorBrush(
                D2D1::ColorF(1.0f, 0, 0, 0.5f),
                &borderBrush
                );
    }

    // Commit changes.
    SafeAttach(&renderTarget_, SafeDetach(&renderTarget));
    SafeAttach(&backBrush_,    SafeDetach(&backBrush));
    SafeAttach(&textBrush_,    SafeDetach(&textBrush));
    SafeAttach(&borderBrush_,  SafeDetach(&borderBrush));

    return hr;
}
Exemplo n.º 20
0
void MWinDeviceImpl::Restore()
{
	assert(not mState.empty());
	mRenderTarget->RestoreDrawingState(mState.top());
	mState.pop();
}
Exemplo n.º 21
0
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nShowCmd) {

	xxd.SetScreenResolution(ScreenWidth, ScreenHeight);

	WNDCLASSEX pencere;
	ZeroMemory(&pencere, sizeof(WNDCLASSEX));

	pencere.cbClsExtra = NULL;
	pencere.cbSize = sizeof(WNDCLASSEX);
	pencere.cbWndExtra = NULL;
	pencere.hCursor = LoadCursor(NULL, IDC_ARROW);
	pencere.hIcon = NULL;
	pencere.hIconSm = NULL;
	pencere.hInstance = hInst;
	pencere.lpfnWndProc = (WNDPROC)WinProc;
	pencere.lpszClassName = "Pencere";
	pencere.lpszMenuName = NULL;
	pencere.style = CS_HREDRAW | CS_VREDRAW;

	RegisterClassEx(&pencere);

	ID2D1Factory* directx = NULL;
	D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED,&directx);

	HWND hWnd = NULL;
	hWnd = CreateWindowEx(NULL, "Pencere", "Direct2D",WS_POPUP | WS_EX_TOPMOST, 0, 0, ScreenWidth, ScreenHeight, NULL, NULL, hInst, NULL);
	
	ShowWindow(hWnd, nShowCmd);

	/*D2D1Rect*/

	RECT rect;
	GetClientRect(hWnd, &rect);

	ID2D1HwndRenderTarget* RenderTarget = NULL;
	directx->CreateHwndRenderTarget(
		D2D1::RenderTargetProperties(),
		D2D1::HwndRenderTargetProperties(hWnd,D2D1::SizeU(rect.right - rect.left, rect.bottom - rect.top)),
		&RenderTarget);

	/*D2D1Rect*/
	/* D2D1Brush */

	/*ID2D1SolidColorBrush* Brush = NULL;
	RenderTarget->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &Brush);*/

	/* D2D1Brush */

	MSG msg;
	ZeroMemory(&msg, sizeof(MSG));

	/*D2D1_ELLIPSE ellipse = D2D1::Ellipse(
		D2D1::Point2F(100.f, 100.f),
		50.f,
		50.f
	);*/

	/*POINT pts;
	pts.x = (ScreenWidth/2) - 25;
	float gravity = 1.0f;
	float y = 20;
	int alo = 0;
	pts.y = (ScreenHeight/2) - 80;*/

	ID2D1Bitmap* Bitmap = NULL;
	IWICImagingFactory* ImagingFactory = NULL;
	CoInitializeEx(NULL, COINIT_MULTITHREADED);
	CoCreateInstance(CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER, IID_IWICImagingFactory, (LPVOID*)&ImagingFactory);
	/*lb.LoadBitmapFromFile(RenderTarget, ImagingFactory, L"Oyuncu/Dokular/Aylak/ön.png", &Bitmap);
	D2D1_SIZE_F size = Bitmap->GetSize();
	D2D1_POINT_2F upperLeftCorner;*/

	btn.InitFactory(ImagingFactory);
	btn.InitTarget(RenderTarget);
	btn.setPos(100, 100);
	btn.getImages();
	btn.InitText(L"Buton Bura Oglim");

	Bush trn;
	trn.InitGadgets(RenderTarget,ImagingFactory);
	trn.InitImage();
	trn.CalcThat();
	trn.InitThat();

	Player plyr;
	plyr.InitFactories(ImagingFactory,RenderTarget);
	plyr.InitIdleImages();
	plyr.InitMoveImages();

	DWORD baslangic_noktasi;
	float deltaTime, oldTime = 0;
	while (TRUE){
		baslangic_noktasi = GetTickCount();
		deltaTime = baslangic_noktasi - oldTime;
		oldTime = baslangic_noktasi;

		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
			if (msg.message == WM_QUIT) {
				break;
			}

			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		//KEY
		if (TUS(VK_SPACE)) {
			//alo = 1;
		}
		if (TUS(VK_LEFT)) {
			tp.x += 2;
			//pts.x -= 2;
		}
		if (TUS(VK_RIGHT)) {
			tp.x -= 2;
			//pts.x += 2;
		}
		if (TUS(VK_UP)) {
			tp.y += 2;
			//pts.y -= 2;
		}
		if (TUS(VK_DOWN)) {
			tp.y -= 2;
			//pts.y += 2;
		}

		plyr.HandleKeysForIdle();
		plyr.HandleKeysForMove(deltaTime);

		/*if (alo == 1) {
			y -= gravity;
			pts.y -= y;
			if (y == -19) {
				alo = 0;
				y = 20.f;
			}
		}*/

		/*if (clps.x != 0 && clps.y!= 0) {
			text.setPos(clps.x, clps.y);
		}*/
		/*upperLeftCorner = D2D1::Point2F(pts.x, pts.y);*/

		//text.setFont(L"Comic Sans MS");
		//LOOP
		RenderTarget->BeginDraw();
		RenderTarget->Clear(D2D1::ColorF(0.25f,0.80f,0.22f,1.f));

		/*Terrain*/
		trn.drawBush();
		/*Terrain*/
		
		//RenderTarget->DrawRectangle(D2D1::RectF(100,100,200,300), Brush);
		//RenderTarget->DrawEllipse(ellipse, Brush, 2.f);
		RenderTarget->SetTransform(D2D1::Matrix3x2F::Translation(0 + tp.x,0 + tp.y));
		/*RenderTarget->DrawBitmap(
			Bitmap,
			D2D1::RectF(
				upperLeftCorner.x,
				upperLeftCorner.y,
				upperLeftCorner.x + 50,
				upperLeftCorner.y + 160),
				1.0,
				D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR
			);*/
		//text.drawatext(50,L"Merhaba",RenderTarget,Brush);

		plyr.Render();

		btn.RenderIt(cups, clk, tp);

		RenderTarget->EndDraw();
		/*if (TUS(VK_ESCAPE)) {
			break;
			PostMessage(hWnd, WM_DESTROY, 0, 0);
		}*/
		//
	}

	directx->Release();
	RenderTarget->Release();
	/*Brush->Release();*/
	Bitmap->Release();
	ImagingFactory->Release();
	xxd.RestoreScreenResolution();
	return 0;
}