예제 #1
0
HRESULT HookIDirect3DDevice9::GetRenderTarget(LPVOID _this,
											  DWORD RenderTargetIndex,
											  IDirect3DSurface9** ppRenderTarget)
{
	LOG_API();
	return pD3Dev->GetRenderTarget(RenderTargetIndex, ppRenderTarget);
}
예제 #2
0
void InitStateDX9(void)
{
	// 取得Direct3D 9裝置
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	// 關閉打光
	device->SetRenderState(D3DRS_LIGHTING, FALSE);
	// 使用trilinear
	device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
	//
	device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
	//
	device->SetRenderState(D3DRS_MULTISAMPLEANTIALIAS, FALSE);

	device->GetRenderTarget(0, &g_pMainFrameBuffer);
	device->GetDepthStencilSurface(&g_pMainDepthBuffer);

	int width, height;
	GutGetWindowSize(width, height);

	g_iFrameBufferWidth = width * 2;
	g_iFrameBufferHeight = height * 2;

	device->CreateTexture(g_iFrameBufferWidth, g_iFrameBufferHeight, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &g_pTexture, NULL);
	device->CreateDepthStencilSurface(g_iFrameBufferWidth, g_iFrameBufferHeight, D3DFMT_D24S8, D3DMULTISAMPLE_NONE, 0, FALSE, &g_pDepthStencil, NULL);
	g_pTexture->GetSurfaceLevel(0, &g_pFrameBuffer);
}
예제 #3
0
파일: Shimmer.cpp 프로젝트: G-11/G11_Tool
LPDIRECT3DTEXTURE9 CShimmer::Render(LPDIRECT3DTEXTURE9 tex)
{
	LPDIRECT3DSURFACE9 OldSurface = nullptr;
	LPDIRECT3DSURFACE9 OldDepth = nullptr;
	LPDIRECT3DDEVICE9 Device = Window::Instance()->Device();

	//深度バッファはそのまま参照する
	Device->GetRenderTarget(0,&OldSurface);

	Device->SetRenderTarget(0,Surface);

	//陽炎マップをクリアする
	Device->Clear(0L,nullptr,(D3DCLEAR_TARGET | D3DCLEAR_STENCIL),0x80808080,1.0f,0);

	Effect->Begin(0,0);
	//陽炎パーティクルを描画
	ShimmerParticle2D::DrawAll();

	//背景を送る
	Effect->SetTexture(Param[BACK_BUFFER],tex);

	//陽炎マップを送る
	Effect->SetTexture(Param[SHIMMER_MAP],Texture);

	if (_BlurFlag)
	{
		//ブラーをかける
		ConductBlur();
	}
	else
	{
		Device->SetRenderTarget(0,ResultSurface);
	}
	Device->Clear(0L,nullptr,(D3DCLEAR_TARGET | D3DCLEAR_STENCIL),D3DXCOLOR(0.0f,0,0,0),1.0f,0);

	//歪ませて描く
	
	Effect->BeginPass(0);

	Device->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);

	Effect->EndPass();
	Effect->End();

	//最初のサーフェイスに戻す
	Device->SetRenderTarget(0,OldSurface);

	//後始末
	if (OldSurface != nullptr)
	{
		OldSurface->Release();
		OldSurface = nullptr;
	}

	return Result;
}
예제 #4
0
void Graphics::setRenderTarget(RenderTarget* target, int num) {
	//if (backBuffer != nullptr) backBuffer->Release();
	if (num == 0) {
		if (backBuffer == nullptr) {
			device->GetRenderTarget(0, &backBuffer);
			device->GetDepthStencilSurface(&depthBuffer);
		}
		affirm(device->SetDepthStencilSurface(target->depthSurface));
	}
	affirm(device->SetRenderTarget(num, target->colorSurface));
}
예제 #5
0
void Graphics::setRenderTarget(RenderTarget* target, int num, int additionalTargets) {
	// if (backBuffer != nullptr) backBuffer->Release();

	System::makeCurrent(target->contextId);

	if (num == 0) {
		if (backBuffer == nullptr) {
			device->GetRenderTarget(0, &backBuffer);
			device->GetDepthStencilSurface(&depthBuffer);
		}
		affirm(device->SetDepthStencilSurface(target->depthSurface));
	}
	affirm(device->SetRenderTarget(num, target->colorSurface));
}
예제 #6
0
void Graphics4::setRenderTargets(RenderTarget** targets, int count) {
	// if (backBuffer != nullptr) backBuffer->Release();

	System::makeCurrent(targets[0]->contextId);

	if (backBuffer == nullptr) {
		device->GetRenderTarget(0, &backBuffer);
		device->GetDepthStencilSurface(&depthBuffer);
	}
	Microsoft::affirm(device->SetDepthStencilSurface(targets[0]->depthSurface));
	for (int i = 0; i < count; ++i) {
		Microsoft::affirm(device->SetRenderTarget(i, targets[i]->colorSurface));
	}
}
static bool CopyRenderTargetToBackground()
{
	bool ret = false;

	LPDIRECT3DDEVICE9 device = (LPDIRECT3DDEVICE9)GetUseDirect3DDevice9();
	if (device == NULL) return nullptr;

	HRESULT hr;
	IDirect3DSurface9* tempRender = nullptr;
	IDirect3DSurface9* tempDepth = nullptr;

	hr = device->GetRenderTarget(0, &tempRender);
	if (FAILED(hr))
	{
		goto Exit;
	}

	hr = device->GetDepthStencilSurface(&tempDepth);
	if (FAILED(hr))
	{
		goto Exit;
	}

	device->SetRenderTarget(0, g_dx9_backgroundSurface);
	device->SetDepthStencilSurface(nullptr);

	D3DSURFACE_DESC desc;
	tempRender->GetDesc(&desc);
	const bool isSame = (desc.Width == g_backgroundWidth && desc.Height == g_backgroundHeight);

	device->StretchRect(
		tempRender,
		nullptr,
		g_dx9_backgroundSurface,
		nullptr,
		(isSame ? D3DTEXF_POINT : D3DTEXF_LINEAR)
		);

	device->SetRenderTarget(0, tempRender);
	device->SetDepthStencilSurface(tempDepth);
	
	ret = true;

Exit:;
	ES_SAFE_RELEASE(tempRender);
	ES_SAFE_RELEASE(tempDepth);

	return ret;
}
VOID Render(float timeDelta)
{
    SetupMatrix() ;

    g_ModelViewCamera->OnFrameMove();

    // Save render target
    g_pd3dDevice->GetRenderTarget(0, &g_pOldRenderTarget) ;

    g_pd3dDevice->SetRenderTarget(0, g_pRenderSurface) ;
    g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 1.0f, 0 );

    // Begin the scene
    if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
    {
        // Without this line, the teapot won't show up, what's the inner stuff of SetTexture?
        g_pd3dDevice->SetTexture(0, NULL) ;

        // Disable lighting, since we didn't specify color for vertex
        g_pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE );
        g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME) ;

        D3DXMATRIX word ;
        D3DXMatrixTranslation(&word, 0.0f, 0.0f, 0.0f) ;

        static float totalTime = 0.0f ;
        totalTime += timeDelta * 2 ;

        D3DXMATRIX rot ;
        D3DXMatrixRotationY(&rot, totalTime) ;

        word *= rot ;
        g_pd3dDevice->SetTransform(D3DTS_WORLD, &word) ;

        g_pTeapotMesh->DrawSubset(0) ;

        // End the scene
        g_pd3dDevice->EndScene();
    }

    // Restore the back buffer
    g_pd3dDevice->SetRenderTarget(0, g_pOldRenderTarget) ;

    RenderCube(timeDelta) ;

    // Present the back-buffer contents to the display
    g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
예제 #9
0
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
static bool CopyRenderTargetToBackground()
{
	bool ret = false;

	HRESULT hr;
	IDirect3DSurface9* tempRender = nullptr;
	IDirect3DSurface9* tempDepth = nullptr;

	hr = g_d3d_device->GetRenderTarget(0, &tempRender);
	if (FAILED(hr))
	{
		goto Exit;
	}

	hr = g_d3d_device->GetDepthStencilSurface(&tempDepth);
	if (FAILED(hr))
	{
		goto Exit;
	}

	g_d3d_device->SetRenderTarget(0, g_backgroundSurface);
	g_d3d_device->SetDepthStencilSurface(nullptr);

	D3DSURFACE_DESC desc;
	tempRender->GetDesc(&desc);
	
	g_d3d_device->StretchRect(
		tempRender,
		nullptr,
		g_backgroundSurface,
		nullptr,
		D3DTEXF_POINT
		);

	g_d3d_device->SetRenderTarget(0, tempRender);
	g_d3d_device->SetDepthStencilSurface(tempDepth);
	
	ret = true;

Exit:;
	ES_SAFE_RELEASE(tempRender);
	ES_SAFE_RELEASE(tempDepth);

	return ret;
}
예제 #10
0
bool ReInitResourceDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	int w,h;
	GutGetWindowSize(w, h);

	float fAspect = (float)h/(float)w;
	g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFOV, fAspect, g_fCameraNearZ, g_fCameraFarZ);

	g_ImageInfo.m_iWidth = g_texture_width;
	g_ImageInfo.m_iHeight = g_texture_height;
	g_ImageInfo.m_bProcedure = true;

	//D3DFORMAT fmt = D3DFMT_A16B16G16R16F;
	D3DFORMAT fmt = D3DFMT_A32B32G32R32F;

	for ( int i=0; i<TEX_TEXTURES; i++ )
	{
		device->CreateTexture(
			g_texture_width, g_texture_height, 
			1, D3DUSAGE_RENDERTARGET, 
			fmt, D3DPOOL_DEFAULT, 
			&g_pTextures[i], NULL);

		if ( NULL==g_pTextures[i] ) return false;

		g_pTextures[i]->GetSurfaceLevel(0, &g_pSurfaces[i]);

		if ( NULL==g_pSurfaces[i] ) return false;
	}

	device->GetRenderTarget(0, &g_pMainFramebuffer);
	device->GetDepthStencilSurface(&g_pMainDepthbuffer);

	device->SetRenderTarget(0, g_pSurfaces[0]);
	device->SetRenderTarget(1, g_pSurfaces[1]);
	
	device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0);

	device->SetRenderTarget(0, g_pMainFramebuffer);
	device->SetRenderTarget(1, NULL);

	return true;
}
예제 #11
0
VOID Render()
{
	SetupMatrix() ;

	g_ModelViewCamera->OnFrameMove();

	g_pd3dDevice->GetRenderTarget(0, &g_pOldRenderTarget) ;

	g_pd3dDevice->SetRenderTarget(0, g_pRenderSurface) ;
	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff0000ff, 1.0f, 0 );

	// Begin the scene
	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	{
		// Without this line, the teapot won't show up, what's the inner stuff of SetTexture?
		g_pd3dDevice->SetTexture(0, NULL) ;

		// Disable lighting, since we didn't specify color for vertex
		g_pd3dDevice->SetRenderState( D3DRS_LIGHTING , FALSE ); 
		g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME) ;
		g_pTeapotMesh->DrawSubset(0) ;

		// End the scene
		g_pd3dDevice->EndScene();
	}

	g_pd3dDevice->SetRenderTarget(0, g_pOldRenderTarget) ;

	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff00ff00, 1.0f, 0 );

	// Begin the scene
	if( SUCCEEDED( g_pd3dDevice->BeginScene() ) )
	{
		g_pd3dDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID) ;

		// Render texture
		RenderQuad() ;

		// End the scene
		g_pd3dDevice->EndScene();
	}

	// Present the back-buffer contents to the display
	g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}
예제 #12
0
	virtual void OnDistorting()
	{
		IDirect3DSurface9* targetSurface = nullptr;
		IDirect3DSurface9* texSurface = nullptr;
		HRESULT hr = S_OK;

		hr = texture->GetSurfaceLevel( 0, &texSurface );
		assert(SUCCEEDED(hr));

		hr = device->GetRenderTarget( 0, &targetSurface );
		assert(SUCCEEDED(hr));

		hr = device->StretchRect( targetSurface, NULL, texSurface, NULL, D3DTEXF_NONE);
		assert(SUCCEEDED(hr));
		
		ES_SAFE_RELEASE( texSurface );
		ES_SAFE_RELEASE( targetSurface );

		renderer->SetBackground( texture );
	}
예제 #13
0
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void Rendering()
{
	g_d3d_device->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,0), 1.0f, 0 );
	
	LPDIRECT3DSURFACE9 targetSurface = NULL;
	g_d3d_device->GetRenderTarget( 0, &targetSurface );
	g_d3d_device->UpdateSurface( g_d3d_clearing_image, NULL, targetSurface, NULL );
	ES_SAFE_RELEASE( targetSurface );

	g_d3d_device->BeginScene();
	
	g_renderer->SetLightDirection(::Effekseer::Vector3D(1.0f, 1.0f, 1.0f));
	g_renderer->SetLightAmbientColor(::Effekseer::Color(40, 40, 40, 255));

	g_renderer->BeginRendering();
	g_manager->Draw();
	g_renderer->EndRendering();

	g_d3d_device->EndScene();
	g_d3d_device->Present( NULL, NULL, NULL, NULL );
}
예제 #14
0
HRESULT KGraphicsEngine::Render()
{
	HRESULT hr = S_OK;
	
	if(!g_hRenderWnd)
		return FALSE;

	if(TRUE!=::GetWindowRect(g_hRenderWnd,&m_RenderWindowRect))
	{
		//MessageBox(g_hBaseWnd,"不知道该渲染到什么地方","Error!",0);

		return FALSE;
	}

	if (m_lpCurScene!=NULL) 
		m_lpCurScene->FrameMove();

	g_cGraphicsTool.SetCurScene(m_lpCurScene);
	
	RECT ScrRect;
	ScrRect.left = 0;
	ScrRect.right = m_RenderWindowRect.right - m_RenderWindowRect.left;
	ScrRect.top = 0;
	ScrRect.bottom = m_RenderWindowRect.bottom - m_RenderWindowRect.top;

	D3DVIEWPORT9 ViewPort;
	ViewPort.X = m_RenderWindowRect.left;
	ViewPort.Y = m_RenderWindowRect.top;
	ViewPort.Width  = ScrRect.right;
	ViewPort.Height = ScrRect.bottom;
	ViewPort.MinZ = 0;
	ViewPort.MaxZ = 1.0f;
	g_pd3dDevice->SetViewport(&ViewPort);
	
	LPDIRECT3DSURFACE9 lpSurface = NULL;
	LPDIRECT3DSURFACE9 lpSurfaceSave = NULL;
	
	if (m_bUseMotionBlur)
	{	
		if (m_BufferTextureID)
		{
			g_pd3dDevice->GetRenderTarget(0,&lpSurfaceSave);
			lpSurfaceSave->Release();
			
			LPTEXTURE pTexture = NULL;
			if (FAILED(g_cTextureTable.GetTexture(&pTexture,m_BufferTextureID)))
			{
				return E_FAIL;
			}
			
			if (FAILED(hr = pTexture->m_lpTexture->GetSurfaceLevel(0,&lpSurface)))
				return hr;
			
			lpSurface->Release();
			g_pd3dDevice->SetRenderTarget(0,lpSurface);
		}
	}


	m_cCamera.zFar = 1000000;
	if (!m_bWindowed)
	{
		m_cCamera.Aspect = m_DisplayMode.Width*1.0f/m_DisplayMode.Height;
	}
	m_cCamera.SetCamera();

	if (m_lpCurScene!=NULL) 
		m_lpCurScene->SetLighting();

	g_pd3dDevice->BeginScene();
	g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL,
		0xFF606060, 1.0f, 0 );

	if (m_lpCurScene!=NULL) 
		m_lpCurScene->Render();
	
	
	//////////////////////////////////////////////////////////////////////////
	/*D3DXVECTOR3 V = D3DXVECTOR3(400*sinf(timeGetTime()*0.001f) ,
		                 100,
		                 400*cosf(timeGetTime()*0.001f) -2000 );
	g_cGraphicsTool.DrawLine(&(V+D3DXVECTOR3(0,35,0)),&(V+D3DXVECTOR3(0,-35,0)),0xffffffff,0xffff0000); 
	g_cGraphicsTool.DrawLine(&(V+D3DXVECTOR3(35,0,0)),&(V+D3DXVECTOR3(-35,0,0)),0xffffffff,0xffff0000); 
	g_cGraphicsTool.DrawLine(&(V+D3DXVECTOR3(0,0,35)),&(V+D3DXVECTOR3(0,0,-35)),0xffffffff,0xffff0000); */
	g_pd3dDevice->EndScene();

	if (m_bUseMotionBlur)
	{
		if (m_BufferTextureID)
		{
			g_pd3dDevice->SetRenderState(D3DRS_FOGENABLE,FALSE);

			g_pd3dDevice->SetRenderTarget(0,lpSurfaceSave);

			Render2SmallerTexture();
			
			g_pd3dDevice->BeginScene();
			g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL,
				0x00000000, 1.0f, 0 );

			D3DXVECTOR2 A(0,0),C((float)m_DisplayMode.Width,(float)m_DisplayMode.Height);
			float K = 3;

			D3DXVECTOR2 T1(5,5);
			D3DXVECTOR2 T2(-3,3);

			
			//g_cTextureTable.SetTexture(0,m_BufferTextureID);
			g_pd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE ,FALSE);
			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,FALSE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);
			
			
			//g_cGraphicsTool.DrawScreenRectNormal(&A,&C,0.0f,0x90FFFFFF,0x90FFFFFF,0x90FFFFFF,0x90FFFFFF);
			
			g_cGraphicsTool.DrawScreenRect(&A,&C,0.0f,0xFFFFFFFF,m_BufferTextureID);

			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);

			if (m_lpCurScene!=NULL) 
			{
				g_cGraphicsTool.DrawScreenRect(&(A-T1),&(C),0.0f,m_lpCurScene->m_Glow.m_AddColor,m_SmallerTextureID);
			}
			/*g_cGraphicsTool.DrawScreenRect(&(A-T1),&(C-T1),0.0f,0xFF808080,m_BufferTextureID);
			g_cGraphicsTool.DrawScreenRect(&(A+T1),&(C+T1),0.0f,0xFF808080,m_BufferTextureID);
			g_cGraphicsTool.DrawScreenRect(&(A-T2),&(C-T2),0.0f,0xFF808080,m_BufferTextureID);
			g_cGraphicsTool.DrawScreenRect(&(A+T2),&(C+T2),0.0f,0xFF808080,m_BufferTextureID);*/
			//g_cGraphicsTool.DrawScreenRectDp3(&A,&C,0.0f,0xFF8F8F8F,m_BufferTextureID);
			g_pd3dDevice->EndScene();
			
		}
	}

	if (m_bWindowed)
	{
		//只将backbuffer中的一个区域提交到窗口上
		if(g_hRenderWnd)
		{
			g_pd3dDevice->Present( &m_RenderWindowRect,NULL, g_hRenderWnd, NULL );
		}
		else
		{
			MessageBox(g_hBaseWnd,"不知道该渲染到什么地方","Error!",0);
		}
	}
	else
	{
		g_pd3dDevice->Present( NULL, NULL, g_hRenderWnd, NULL );
	}

	g_dwRenderCount++;
	return TRUE;
}
예제 #15
0
HRESULT KGraphicsEngine::Render2SmallerTexture()
{
	LPTEXTURE pTexBuffer  = NULL;
	LPTEXTURE pTexSmaller = NULL;
	LPTEXTURE pTexBlur    = NULL;

	if (FAILED(g_cTextureTable.GetTexture(&pTexBuffer,m_BufferTextureID)))
		return E_FAIL;
	if (FAILED(g_cTextureTable.GetTexture(&pTexSmaller,m_SmallerTextureID)))
		return E_FAIL;
	if (FAILED(g_cTextureTable.GetTexture(&pTexBlur,m_BlurTextureID)))
		return E_FAIL;
	if(!pTexBuffer->m_lpTexture)
		return E_FAIL;
	if(!pTexSmaller->m_lpTexture)
		return E_FAIL;
	if(!pTexBlur->m_lpTexture)
		return E_FAIL;
	D3DSURFACE_DESC Desc;
	if(FAILED(pTexSmaller->m_lpTexture->GetLevelDesc(0,&Desc)))
		return E_FAIL;
	D3DSURFACE_DESC DescBlur;
	if(FAILED(pTexBlur->m_lpTexture->GetLevelDesc(0,&DescBlur)))
		return E_FAIL;

	LPDIRECT3DSURFACE9 lpSurfaceSmaller = NULL;
	if(FAILED(pTexSmaller->m_lpTexture->GetSurfaceLevel(0,&lpSurfaceSmaller)))
		return E_FAIL;
	lpSurfaceSmaller->Release();
	LPDIRECT3DSURFACE9 lpSurfaceBlur = NULL;
	if(FAILED(pTexBlur->m_lpTexture->GetSurfaceLevel(0,&lpSurfaceBlur)))
		return E_FAIL;
	lpSurfaceBlur->Release();

	D3DXMATRIX Mat_View_Save;
	D3DXMATRIX Mat_Proj_Save;
	LPDIRECT3DSURFACE9 lpSurfaceSave = NULL;
	D3DVIEWPORT9 ViewPort,ViewPortBlur,ViewPortSave;
	//////////////////////////////////////////////////////////////////////////
	//Save back buffer & transform & viewport
	g_pd3dDevice->GetRenderTarget(0,&lpSurfaceSave);
	lpSurfaceSave->Release();
	g_pd3dDevice->GetTransform( D3DTS_VIEW, &Mat_View_Save );
	g_pd3dDevice->GetTransform( D3DTS_PROJECTION, &Mat_Proj_Save );
	g_pd3dDevice->GetViewport(&ViewPortSave);


	//////////////////////////////////////////////////////////////////////////

	ViewPort.X = 0;ViewPort.Y = 0;
	ViewPort.Width = Desc.Width;
	ViewPort.Height = Desc.Height;
	ViewPort.MinZ = 0;ViewPort.MaxZ = 1.0f;

	ViewPortBlur.X = 0;ViewPortBlur.Y = 0;
	ViewPortBlur.Width  = DescBlur.Width;
	ViewPortBlur.Height = DescBlur.Height;
	ViewPortBlur.MinZ = 0;ViewPortBlur.MaxZ = 1.0f;

	D3DXVECTOR2 A(0,0);
	D3DXVECTOR2 C((float)Desc.Width,(float)Desc.Height);

	D3DXVECTOR2 A1(0,0);
	D3DXVECTOR2 C1((float)DescBlur.Width,(float)DescBlur.Height);

	//////////////////////////////////////////////////////////////////////////
	g_pd3dDevice->SetViewport(&ViewPort);
	g_pd3dDevice->SetRenderTarget(0,lpSurfaceSmaller);
	//////////////////////////////////////////////////////////////////////////
	//reade began to render
	//g_pd3dDevice->BeginScene();

	g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 
		0x00000000, 1.0f, 0 );

	g_pd3dDevice->SetRenderState( D3DRS_CULLMODE,  D3DCULL_NONE );
	float K = 2;
	D3DXVECTOR2 T1( K,K);
	D3DXVECTOR2 T2(-K,K);

	g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
	g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

	DWORD Color = m_lpCurScene->m_Glow.m_GateColor;
	g_cTextureTable.SetTexture(0,m_BufferTextureID);
	g_pd3dDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_SUBTRACT);
	g_pd3dDevice->SetTextureStageState(0,D3DTSS_COLORARG1,D3DTA_TEXTURE);
	g_pd3dDevice->SetTextureStageState(0,D3DTSS_COLORARG2,D3DTA_DIFFUSE);

	/*g_cTextureTable.SetTexture(1,m_BufferTextureID);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLOROP,D3DTOP_MODULATE2X);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLORARG1,D3DTA_TEXTURE);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLORARG2,D3DTA_CURRENT);*/

	g_cGraphicsTool.DrawScreenRectNormal(&A,&C,0.0f,Color,Color,Color,Color);

	//g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	//g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);
	//g_cGraphicsTool.DrawScreenRect(&A,&C,0.0f,Color,m_SmallerTextureID);
	//g_cGraphicsTool.DrawScreenRect(&(A-T1),&(C+T1),0.0f,Color,m_SmallerTextureID);

	//g_cGraphicsTool.DrawScreenRect(&A,&C,0.0f,Color,m_BufferTextureID);
	/*g_cGraphicsTool.DrawScreenRect(&(A-T1),&(C-T1),0.0f,Color,m_BufferTextureID);
	g_cGraphicsTool.DrawScreenRect(&(A+T1),&(C+T1),0.0f,Color,m_BufferTextureID);
	g_cGraphicsTool.DrawScreenRect(&(A-T2),&(C-T2),0.0f,Color,m_BufferTextureID);
	g_cGraphicsTool.DrawScreenRect(&(A+T2),&(C+T2),0.0f,Color,m_BufferTextureID);*/

	if(1)
	{
		//////////////////////////////////////////////////////////////////////////
		Color = 0x30FFFFFF;
		for(int i=0;i<8;i++)
		{
			g_pd3dDevice->SetViewport(&ViewPortBlur);
			g_pd3dDevice->SetRenderTarget(0,lpSurfaceBlur);

			//if(i==0)
			{
				g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 
					0x00000000, 1.0f, 0 );
			}

			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

			g_cGraphicsTool.DrawScreenRect(&A1,&C1,0.0f,0xFFFFFFFF,m_SmallerTextureID);

			g_pd3dDevice->SetViewport(&ViewPort);
			g_pd3dDevice->SetRenderTarget(0,lpSurfaceSmaller);

			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_BLENDFACTOR);
			g_pd3dDevice->SetRenderState(D3DRS_TEXTUREFACTOR,0x60606060);

			g_cGraphicsTool.DrawScreenRect(&(A-T1),&(C+T1),0.0f,Color,m_BlurTextureID);
		}
	}
	else
	{


		//g_pd3dDevice->SetRenderState(D3DRS_TEXTUREFACTOR,0x60606060);

		for(int i=0;i<10;i++)
		{
			g_pd3dDevice->SetViewport(&ViewPortBlur);
			g_pd3dDevice->SetRenderTarget(0,lpSurfaceBlur);

			g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 
				0x00000000, 1.0f, 0 );

			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

			g_cGraphicsTool.DrawScreenRect(&A1,&C1,0.0f,0xFFFFFFFF,m_SmallerTextureID);

			g_pd3dDevice->SetViewport(&ViewPort);
			g_pd3dDevice->SetRenderTarget(0,lpSurfaceSmaller);

			g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
			g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
			g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_ONE);

			Color = 0x00FFFFFF|(255-i*25)<<24;
			float K = 5;
			T1 = D3DXVECTOR2(K*i,K*i);
			T2 = D3DXVECTOR2(-K*i,K*i);

			g_cGraphicsTool.DrawScreenRect(&(A-T2),&(C-T2),0.0f,Color,m_BlurTextureID);
			/*g_cGraphicsTool.DrawScreenRect(&(A+T1),&(C+T1),0.0f,Color,m_BlurTextureID);
			g_cGraphicsTool.DrawScreenRect(&(A-T2),&(C-T2),0.0f,Color,m_BlurTextureID);
			g_cGraphicsTool.DrawScreenRect(&(A+T2),&(C+T2),0.0f,Color,m_BlurTextureID);*/
		}

		/*g_pd3dDevice->SetViewport(&ViewPortBlur);
		g_pd3dDevice->SetRenderTarget(0,lpSurfaceBlur);
		g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 
			0x00000000, 1.0f, 0 );
		g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
		g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_INVSRCALPHA);

		g_cGraphicsTool.DrawScreenRect(&A1,&C1,0.0f,0xFFFFFFFF,m_SmallerTextureID);
		g_pd3dDevice->SetViewport(&ViewPort);
		g_pd3dDevice->SetRenderTarget(0,lpSurfaceSmaller);

		g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE,TRUE);
		g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND,D3DBLEND_BLENDFACTOR);
		g_pd3dDevice->SetRenderState(D3DRS_TEXTUREFACTOR,0x60606060);*/
		
		Color = 0x30FFFFFF;
		g_cGraphicsTool.DrawScreenRect(&(A),&(C),0.0f,Color,m_BlurTextureID);

	}
	


	//g_pd3dDevice->EndScene();
	//////////////////////////////////////////////////////////////////////////
	//Restore
	g_pd3dDevice->SetTransform( D3DTS_VIEW, &Mat_View_Save );
	g_pd3dDevice->SetTransform( D3DTS_PROJECTION, &Mat_Proj_Save );
	g_pd3dDevice->SetRenderTarget(0,lpSurfaceSave);
	g_pd3dDevice->SetViewport(&ViewPortSave);

	g_cTextureTable.SetTexture(1,NULL);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLOROP,D3DTOP_DISABLE);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLORARG1,D3DTA_TEXTURE);
	g_pd3dDevice->SetTextureStageState(1,D3DTSS_COLORARG2,D3DTA_CURRENT);

	return S_OK;
}
예제 #16
0
//*************************************************************************************************************
void Render(float alpha, float elapsedtime)
{
	static float time = 0;

	D3DXMATRIX	inv;
	D3DXVECTOR3	axis(0, 1, 0);
	D3DXVECTOR4	texelsize(1.0f / (float)screenwidth, 1.0f / (float)screenheight, 0, 1);
	
	LPDIRECT3DSURFACE9 oldtarget = NULL;

	time += elapsedtime;

	D3DXMatrixRotationAxis(&inv, &axis, time);
	D3DXMatrixScaling(&world, 0.3f, 0.3f, 0.3f);
	//D3DXMatrixScaling(&world, 0.6f, 0.6f, 0.6f);
	D3DXMatrixMultiply(&world, &world, &inv);
	D3DXMatrixInverse(&inv, NULL, &world);

	device->SetTexture(0, texture);
	device->SetTexture(1, intensity);

	effect->SetMatrix("matWorld", &world);
	effect->SetMatrix("matWorldInv", &inv);
	effect->SetMatrix("matView", &view);
	effect->SetMatrix("matProj", &proj);

	if( useedgedetect )
	{
		device->GetRenderTarget(0, &oldtarget);
		device->SetRenderTarget(0, colorsurface);
		device->SetRenderTarget(1, normalsurface);
	}

	device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER|D3DCLEAR_STENCIL, 0xff6694ed, 1.0f, 0);

	if( SUCCEEDED(device->BeginScene()) )
	{
		// draw scene + normals/depth
		effect->SetTechnique("celshading");

		effect->Begin(NULL, 0);
		effect->BeginPass(0);
		{
			mesh->DrawSubset(0);
		}
		effect->EndPass();
		effect->End();

		if( useedgedetect )
		{
			// edge detection
			device->SetVertexDeclaration(vertexdecl);
			device->SetRenderTarget(0, edgesurface);
			device->SetRenderTarget(1, NULL);
			device->SetTexture(0, normaltarget);
			device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);

			effect->SetTechnique("edgedetect");
			effect->SetVector("texelSize", &texelsize);

			effect->Begin(NULL, 0);
			effect->BeginPass(0);
			{
				device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
			}
			effect->EndPass();
			effect->End();

			// put together
			device->SetRenderTarget(0, oldtarget);
			device->SetTexture(0, colortarget);
			device->SetTexture(2, edgetarget);
			device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);

			oldtarget->Release();
			effect->SetTechnique("final");

			effect->Begin(NULL, 0);
			effect->BeginPass(0);
			{
				device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
			}
			effect->EndPass();
			effect->End();
		}
		else
		{
			D3DXMATRIX offproj;

			// use the stencil buffer
			device->SetRenderState(D3DRS_COLORWRITEENABLE, 0);
			device->SetRenderState(D3DRS_ZWRITEENABLE, FALSE);
			device->SetRenderState(D3DRS_STENCILENABLE, TRUE);
			device->SetRenderState(D3DRS_ZENABLE, FALSE);

			device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_ALWAYS);
			device->SetRenderState(D3DRS_STENCILREF, 1);
			device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_REPLACE);

			device->SetTransform(D3DTS_WORLD, &world);
			device->SetTransform(D3DTS_VIEW, &view);

			float thickness = 3.5f;

			// render object 4 times with offseted frustum
			for( float i = -thickness; i < thickness + 1; i += 2 * thickness )
			{
				for( float j = -thickness; j < thickness + 1; j += 2 * thickness )
				{
					D3DXMatrixTranslation(&offproj, i / (float)screenwidth, j / (float)screenheight, 0);
					D3DXMatrixMultiply(&offproj, &proj, &offproj);

					device->SetTransform(D3DTS_PROJECTION, &offproj);
					mesh->DrawSubset(0);
				}
			}

			// erase area in the center
			device->SetRenderState(D3DRS_STENCILREF, 0);
			device->SetTransform(D3DTS_PROJECTION, &proj);

			mesh->DrawSubset(0);

			// now render outlines
			device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED|D3DCOLORWRITEENABLE_GREEN|D3DCOLORWRITEENABLE_BLUE|D3DCOLORWRITEENABLE_ALPHA);
			device->SetRenderState(D3DRS_STENCILFUNC, D3DCMP_NOTEQUAL);
			device->SetRenderState(D3DRS_STENCILPASS, D3DSTENCILOP_KEEP);
			device->SetRenderState(D3DRS_STENCILFAIL, D3DSTENCILOP_KEEP);

			device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);

			device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
			device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_CONSTANT);
			device->SetTextureStageState(0, D3DTSS_CONSTANT, 0);
			{
				device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, vertices, sizeof(D3DXVECTOR4) + sizeof(D3DXVECTOR2));
			}
			device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
			device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);

			device->SetRenderState(D3DRS_ZENABLE, TRUE);
			device->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);
			device->SetRenderState(D3DRS_STENCILENABLE, FALSE);
		}

		device->SetTexture(2, NULL);

		// render text
		device->SetFVF(D3DFVF_XYZRHW|D3DFVF_TEX1);
		device->SetRenderState(D3DRS_ZENABLE, FALSE);
		device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
		device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
		device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

		device->SetTexture(0, text);
		device->DrawPrimitiveUP(D3DPT_TRIANGLELIST, 2, textvertices, 6 * sizeof(float));

		device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
		device->SetRenderState(D3DRS_ZENABLE, TRUE);

		device->SetTexture(0, NULL);
		device->EndScene();
	}

	device->Present(NULL, NULL, NULL, NULL);
}
예제 #17
0
bool ReInitResourceDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	GutGetWindowSize(g_iWidth, g_iHeight);

	g_proj_matrix = GutMatrixOrthoRH_DirectX(g_iWidth, g_iHeight, 0.0f, 100.0f);

	int w = g_iWidth;
	int h = g_iHeight;

	g_ImageInfo.m_iWidth = g_iWidth;
	g_ImageInfo.m_iHeight = g_iHeight;
	g_ImageInfo.m_bProcedure = true;

	//D3DFORMAT fmt = D3DFMT_G16R16;
	D3DFORMAT fmt = D3DFMT_A8R8G8B8;

	device->SetRenderState(D3DRS_LIGHTING, FALSE);

	device->CreateTexture(
		w, h, 
		1, D3DUSAGE_RENDERTARGET, 
		fmt, D3DPOOL_DEFAULT, 
		&g_pTextures[TEX_HEIGHT0], NULL);
	if ( NULL==g_pTextures[TEX_HEIGHT0] ) return false;

	g_pTextures[TEX_HEIGHT0]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT0]);
	if ( NULL==g_pSurfaces[TEX_HEIGHT0] ) return false;

	device->CreateTexture(
		w, h, 
		1, D3DUSAGE_RENDERTARGET, 
		fmt, D3DPOOL_DEFAULT, 
		&g_pTextures[TEX_HEIGHT1], NULL);
	if ( NULL==g_pTextures[TEX_HEIGHT1] ) return false;

	if ( NULL==g_pTextures[TEX_HEIGHT1] ) return false;
	g_pTextures[TEX_HEIGHT1]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT1]);

	device->CreateTexture(
		w, h, 
		1, D3DUSAGE_RENDERTARGET, 
		fmt, D3DPOOL_DEFAULT, 
		&g_pTextures[TEX_HEIGHT2], NULL);
	if ( NULL==g_pTextures[TEX_HEIGHT2] ) return false;

	g_pTextures[TEX_HEIGHT2]->GetSurfaceLevel(0, &g_pSurfaces[TEX_HEIGHT2]);
	if ( NULL==g_pSurfaces[TEX_HEIGHT2] ) return false;

	device->CreateTexture(
		w, h, 
		1, D3DUSAGE_RENDERTARGET, 
		D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, 
		&g_pTextures[TEX_NORMAL], NULL);

	if ( NULL==g_pTextures[TEX_NORMAL] ) return false;

	g_pTextures[TEX_NORMAL]->GetSurfaceLevel(0, &g_pSurfaces[TEX_NORMAL]);

	if ( NULL==g_pSurfaces[TEX_NORMAL] ) return false;

	device->GetRenderTarget(0, &g_pMainFramebuffer);
	device->GetDepthStencilSurface(&g_pMainDepthbuffer);

	device->SetRenderTarget(0, g_pSurfaces[0]);
	device->SetRenderTarget(1, g_pSurfaces[1]);
	device->SetRenderTarget(2, g_pSurfaces[2]);
	
	device->Clear(0, NULL, D3DCLEAR_TARGET, 0x0, 1.0f, 0);

	device->SetRenderTarget(0, g_pMainFramebuffer);
	device->SetRenderTarget(1, NULL);
	device->SetRenderTarget(2, NULL);

	device->SetRenderState(D3DRS_NORMALIZENORMALS, TRUE);
	device->SetRenderState(D3DRS_DIFFUSEMATERIALSOURCE, D3DMCS_MATERIAL);
	device->SetRenderState(D3DRS_SPECULARMATERIALSOURCE, D3DMCS_MATERIAL);

	return true;
}
예제 #18
0
HRESULT KG3DGraphicsEngine::ScreenShotImpl()
{
    HRESULT hResult  = E_FAIL;
    HRESULT hRetCode = E_FAIL;

    IDirect3DSurface9* pFrameSurface = NULL;
    IDirect3DTexture9* pTextureSys = NULL;
    ID3DXBuffer* pBuffer = NULL;
    D3DVIEWPORT9 ViewPort;
    RECT RectView;

    ASSERT(m_eShotImageType != D3DXIFF_FORCE_DWORD);

    hRetCode = g_pd3dDevice->GetRenderTarget(0, &pFrameSurface);
    KG_COM_PROCESS_ERROR(hRetCode);

    g_pd3dDevice->GetViewport(&ViewPort);
    SetRect(&RectView, ViewPort.X, ViewPort.Y, ViewPort.X + ViewPort.Width, ViewPort.Y + ViewPort.Height);

    if (m_eShotImageType == D3DXIFF_JPG)
    {
        D3DSURFACE_DESC SurfaceDesc;
        D3DLOCKED_RECT LockRect;
        
        hRetCode = D3DXSaveSurfaceToFileInMemory(&pBuffer, D3DXIFF_BMP, pFrameSurface, NULL, &RectView);
        KG_COM_PROCESS_ERROR(hRetCode);

        hRetCode = D3DXCreateTextureFromFileInMemoryEx(g_pd3dDevice, 
            pBuffer->GetBufferPointer(), 
            pBuffer->GetBufferSize(),
            ViewPort.Width,
            ViewPort.Height,
            1,
            0,
            D3DFMT_A8R8G8B8,
            D3DPOOL_SCRATCH,
            D3DX_DEFAULT,
            D3DX_DEFAULT,
            0,
            NULL,
            NULL,
            &pTextureSys);
        KG_COM_PROCESS_ERROR(hRetCode);


        /*
        hRetCode = D3DXSaveSurfaceToFile(TEXT("__temp_shot.bmp"), D3DXIFF_BMP, pFrameSurface, NULL, &RectView);
        KG_COM_PROCESS_ERROR(hRetCode);

        hRetCode = D3DXCreateTextureFromFileEx(g_pd3dDevice, 
            TEXT("__temp_shot.bmp"), 
            ViewPort.Width,
            ViewPort.Height,
            1,
            0,
            D3DFMT_A8R8G8B8,
            D3DPOOL_SCRATCH,
            D3DX_DEFAULT,
            D3DX_DEFAULT,
            0,
            NULL,
            NULL,
            &pTextureSys);
        KG_COM_PROCESS_ERROR(hRetCode); */

        pTextureSys->GetLevelDesc(0, &SurfaceDesc);

        if (SUCCEEDED(pTextureSys->LockRect(0, &LockRect, NULL, D3DLOCK_NOSYSLOCK)))
        {
            struct _Rgba { BYTE r; BYTE g; BYTE b; BYTE a;};
            struct _Rgb  { BYTE b; BYTE g; BYTE r; };
            _Rgb* pRgb = new _Rgb[SurfaceDesc.Height * SurfaceDesc.Width];

            for (UINT v = 0; v < SurfaceDesc.Height; ++v)
            {
                _Rgba* pRgba = (_Rgba*)((BYTE*)LockRect.pBits + LockRect.Pitch * v);

                for (UINT u = 0; u < SurfaceDesc.Width; ++u)
                {
                    pRgb[v * SurfaceDesc.Width + u].r = pRgba[u].r;
                    pRgb[v * SurfaceDesc.Width + u].g = pRgba[u].g;
                    pRgb[v * SurfaceDesc.Width + u].b = pRgba[u].b;
                }
            }

            JpegFile::RGBToJpegFile(m_szShotPath, (BYTE*)pRgb, SurfaceDesc.Width, SurfaceDesc.Height, TRUE, m_nShotImageQuty);

            delete[] pRgb;
            pTextureSys->UnlockRect(0);
        }
        else
        {
            KG_PROCESS_ERROR(FALSE);
        }
    }
    else
    {
        hRetCode = D3DXSaveSurfaceToFile(m_szShotPath, m_eShotImageType, pFrameSurface, NULL, &RectView);
        KG_COM_PROCESS_ERROR(hRetCode);
    }

    hResult = S_OK;
Exit0 :
    SAFE_RELEASE(pBuffer);
    SAFE_RELEASE(pTextureSys);
    SAFE_RELEASE(pFrameSurface);
    return hResult;
}
예제 #19
0
bool ReInitResourceDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	device->SetRenderState(D3DRS_LIGHTING, FALSE);

	int w, h;
	GutGetWindowSize(w, h);
	
	g_ImageInfo.m_iWidth = w;
	g_ImageInfo.m_iHeight = h;
	
	float aspect = (float)h/(float)w;
	g_proj_matrix = GutMatrixPerspectiveRH_DirectX(g_fFovW, aspect, g_fNearZ, g_fFarZ);
	device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&g_proj_matrix);

	int width = w;
	int height = h;
	
	D3DFORMAT fmt = D3DFMT_A16B16G16R16F;

	device->CreateTexture(width, height, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[FULLSIZE], NULL);

	device->CreateTexture(256, 256, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_256x256], NULL);

	device->CreateTexture(64, 64, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_64x64], NULL);

	device->CreateTexture(16, 16, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_16x16], NULL);

	device->CreateTexture(4, 4, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[DOWNSAMPLED_4x4], NULL);

	device->CreateTexture(1, 1, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_PREVIOUS], NULL);

	device->CreateTexture(1, 1, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_CURRENT], NULL);

	device->CreateTexture(1, 1, 1, 
		D3DUSAGE_RENDERTARGET, fmt, 
		D3DPOOL_DEFAULT, &g_pFrameBuffer[LUMINANCE_TEMP], NULL);

	for ( int i=0; i<NUM_FRAMEBUFFERS; i++ )
	{
		if ( g_pFrameBuffer[i]==NULL )
			return false;
		g_pFrameBuffer[i]->GetSurfaceLevel(0, &g_pFrameSurface[i]);
	}

	for ( int i=0; i<4; i++ )
	{
		device->SetSamplerState(i,  D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(i,  D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(i,  D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

		device->SetSamplerState(i,  D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
		device->SetSamplerState(i,  D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);
	}

	device->GetRenderTarget(0, &g_pMainSurface); g_pMainSurface->Release();
	device->GetDepthStencilSurface(&g_pDepthStencilSurface); g_pDepthStencilSurface->Release();

	return true;
}
예제 #20
0
HRESULT CProteinVistaRenderer::SaveScreenImage ( LPCSTR fileName, long imageWidth, long imageHeight , D3DXIMAGE_FILEFORMAT format)
{
	HRESULT hr;
	LPDIRECT3DDEVICE9 pDev = GetD3DDevice();

	BOOL bChangeSize = TRUE;
	if ( imageWidth == -1 || imageHeight == -1 )
	{
		bChangeSize = FALSE;
		imageWidth = m_d3dpp.BackBufferWidth;
		imageHeight = m_d3dpp.BackBufferHeight;
	}

	//    홀수이면 짝수로 바꾼다.
	if ( imageWidth/2 != (imageWidth+1)/2 )
	{
		imageWidth = (imageWidth/2)*2;
		bChangeSize = TRUE;
	}
	if ( imageHeight/2 != (imageHeight+1)/2 )
	{
		imageHeight = (imageHeight/2)*2;
		bChangeSize = TRUE;
	}

	long imageWidthOld = m_d3dpp.BackBufferWidth;
	long imageHeightOld = m_d3dpp.BackBufferHeight;

	if ( bChangeSize == TRUE )
	{
		m_d3dpp.BackBufferWidth  = imageWidth;
		m_d3dpp.BackBufferHeight = imageHeight;

		m_d3dSettings.Windowed_Width = m_d3dpp.BackBufferWidth;
		m_d3dSettings.Windowed_Height = m_d3dpp.BackBufferHeight;

		if( FAILED( hr = Reset3DEnvironment() ) )
		{
			if( hr == D3DERR_DEVICELOST )
			{
				m_bDeviceLost = true;
			}
			else
			{
				return E_FAIL;
			}
		}
	}

	LPDIRECT3DSURFACE9 renderTargetOrig = NULL;	
	hr = pDev->GetRenderTarget(0,&renderTargetOrig);

	LPDIRECT3DSURFACE9 renderTargetCapture; // 캡쳐된 내용이 들어갈 서피스
	D3DSURFACE_DESC desc;
	renderTargetOrig->GetDesc(&desc);

	pDev->CreateRenderTarget(desc.Width, desc.Height, desc.Format, desc.MultiSampleType , desc.MultiSampleQuality, FALSE , &renderTargetCapture, NULL);

	pDev->SetRenderTarget(0, renderTargetCapture);
	pDev->Clear(0, NULL, D3DCLEAR_TARGET, 0, 1, 0);

	//    
	Render();

	pDev->SetRenderTarget(0, renderTargetOrig);
	SAFE_RELEASE(renderTargetOrig);

	// save the image to specified file
	CString filename(fileName);
	hr=D3DXSaveSurfaceToFile(filename,format,renderTargetCapture,NULL,NULL);
	if ( FAILED(hr) )
		return hr;

	SAFE_RELEASE(renderTargetCapture);

	//
	// return status of save to caller
	// 
	if ( bChangeSize == TRUE )
	{
		m_d3dpp.BackBufferWidth  = imageWidthOld;
		m_d3dpp.BackBufferHeight = imageHeightOld;

		m_d3dSettings.Windowed_Width = m_d3dpp.BackBufferWidth;
		m_d3dSettings.Windowed_Height = m_d3dpp.BackBufferHeight;

		if( FAILED( hr = Reset3DEnvironment() ) )
		{
			if( hr == D3DERR_DEVICELOST )
			{
				m_bDeviceLost = true;
			}
			else
			{
				return E_FAIL;
			}
		}

		Render3DEnvironment();
	}

	return hr;
}
예제 #21
0
static LPDIRECT3DTEXTURE9 BlurTexture(LPDIRECT3DTEXTURE9 pSource)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	Matrix4x4 identiyMatrix = Matrix4x4::IdentityMatrix();

	device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &identiyMatrix);
	device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &identiyMatrix);
	device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &identiyMatrix);

	LPDIRECT3DSURFACE9 pFrameBufferBackup, pDepthBufferBackup;
	device->GetRenderTarget(0, &pFrameBufferBackup); pFrameBufferBackup->Release();
	device->GetDepthStencilSurface(&pDepthBufferBackup); pDepthBufferBackup->Release();
	device->SetRenderState(D3DRS_CULLMODE , D3DCULL_NONE);

	float weight_table[7] = {1.0f, 3.0f, 4.0f, 5.0f, 4.0f, 3.0f, 1.0f};
	float uv_offset_table[7] = {-3.0f, -2.0f, -1.0f, 0.0f, 1.0f, 2.0f, 3.0f};

	float sum = 0.0f;

	for ( int i=0; i<7; i++ )
	{
		sum += weight_table[i];
	}

	for ( int i=0; i<7; i++ )
	{
		weight_table[i] /= sum;
	}

	Vector4 vOneTexel_X(1.0f/(float)g_framebuffer_w, 0.0f, 0.0f, 0.0f);
	Vector4 vOneTexel_Y(0.0f, 1.0f/(float)g_framebuffer_h, 0.0f, 0.0f);
	Vertex_VT temp_quad[4];

	LPDIRECT3DSURFACE9 pSurface;
	g_pBlurTextures[0]->GetSurfaceLevel(0, &pSurface); 

	device->SetRenderTarget(0, pSurface);
	device->SetDepthStencilSurface(NULL);
	device->SetRenderState(D3DRS_ZENABLE, FALSE);
	device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0);

	device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
	device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ONE);

	device->SetTexture(0, pSource);
	device->SetFVF(D3DFVF_XYZW|D3DFVF_TEX1); 

	// 設定顏色來源為 texture factor * texture
	device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TFACTOR);
	device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);

	// X方向blur
	for ( int i=0; i<7; i++ )
	{
		Vector4 vOffset = uv_offset_table[i] * vOneTexel_X;

		for ( int p=0; p<4; p++ )
		{
			temp_quad[p].m_Position = g_Quad[p].m_Position;
			temp_quad[p].m_Texcoord = g_Quad[p].m_Texcoord + vOffset;
		}

		int weight = (int) (weight_table[i] * 255);
		device->SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_RGBA(weight, weight, weight, weight));
		device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, temp_quad, sizeof(Vertex_VT));
	}

	pSurface->Release();

	g_pBlurTextures[1]->GetSurfaceLevel(0, &pSurface); 
	device->SetRenderTarget(0, pSurface);
	device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_RGBA(0, 0, 0, 0), 1.0f, 0);
	device->SetTexture(0, g_pBlurTextures[0]);

	// Y方向blur
	for ( int i=0; i<7; i++ )
	{
		Vector4 vOffset = uv_offset_table[i] * vOneTexel_Y;

		for ( int p=0; p<4; p++ )
		{
			temp_quad[p].m_Position = g_Quad[p].m_Position;
			temp_quad[p].m_Texcoord = g_Quad[p].m_Texcoord + vOffset;
		}

		int weight = (int) (weight_table[i] * 255);
		device->SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_RGBA(weight, weight, weight, weight));
		device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, temp_quad, sizeof(Vertex_VT));
	}

	pSurface->Release();

	// 還原設定
	device->SetRenderState(D3DRS_TEXTUREFACTOR, D3DCOLOR_RGBA(255, 255, 255, 255));
	device->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
	device->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_CURRENT);
	device->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
	device->SetRenderState(D3DRS_ZENABLE, TRUE);
	device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

	device->SetRenderTarget(0, pFrameBufferBackup);
	device->SetDepthStencilSurface(pDepthBufferBackup);

	return g_pBlurTextures[1];
}
void RenderWithIrregularPCF(
	const D3DXMATRIX& viewproj,
	const D3DXVECTOR3& eye,
	const D3DXMATRIX& lightview,
	const D3DXMATRIX& lightproj,
	const D3DXVECTOR4& lightpos,
	const D3DXVECTOR4& clipplanes,
	const D3DXVECTOR4& texelsize)
{
	LPDIRECT3DSURFACE9 oldsurface		= NULL;
	LPDIRECT3DSURFACE9 shadowsurface	= NULL;
	D3DXVECTOR4 noisesize(16.0f, 16.0f, 0, 1);

	// STEP 1: render shadow map
	shadowmap->GetSurfaceLevel(0, &shadowsurface);

	device->GetRenderTarget(0, &oldsurface);
	device->SetRenderTarget(0, shadowsurface);
	device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0);
	//device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);

	shadowsurface->Release();

	pcfirreg->SetTechnique("shadowmap");
	pcfirreg->SetMatrix("lightView", &lightview);
	pcfirreg->SetMatrix("lightProj", &lightproj);
	pcfirreg->SetVector("clipPlanes", &clipplanes);

	pcfirreg->Begin(NULL, 0);
	pcfirreg->BeginPass(0);
	{
		RenderScene(pcfirreg, 1); // caster
		RenderScene(pcfirreg, 3); // caster & receiver
	}
	pcfirreg->EndPass();
	pcfirreg->End();

	// STEP 2: render scene
	//device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
	device->SetRenderTarget(0, oldsurface);
	device->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, 0xff6694ed, 1.0f, 0);
	device->SetRenderState(D3DRS_SRGBWRITEENABLE, TRUE);

	oldsurface->Release();

	device->SetTexture(1, shadowmap);
	device->SetTexture(2, noise);

	pcfirreg->SetTechnique("irregular_light");
	//pcfirreg->SetTechnique("irregular_screen");
	pcfirreg->SetMatrix("matViewProj", &viewproj);
	pcfirreg->SetMatrix("lightView", &lightview);
	pcfirreg->SetMatrix("lightProj", &lightproj);
	pcfirreg->SetVector("clipPlanes", &clipplanes);
	pcfirreg->SetVector("lightPos", &lightpos);
	pcfirreg->SetVector("eyePos", (D3DXVECTOR4*)&eye);
	pcfirreg->SetVector("texelSize", &texelsize);
	pcfirreg->SetVector("noiseSize", &noisesize);

	pcfirreg->Begin(NULL, 0);
	pcfirreg->BeginPass(0);
	{
		RenderScene(pcfirreg, 2); // receiver
		RenderScene(pcfirreg, 3); // caster & receiver
	}
	pcfirreg->EndPass();
	pcfirreg->End();

	device->SetRenderState(D3DRS_SRGBWRITEENABLE, FALSE);
}
예제 #23
0
// 使用DirectX 9來繪圖
void RenderFrameDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
	Vector4 vPlane(0.0f, 0.0f, 1.0f, -g_mirror_z);

	// 開始下繪圖指令
	device->BeginScene(); 

	{
		LPDIRECT3DSURFACE9 pFrameBufferBackup, pDepthBufferBackup;
		device->GetRenderTarget(0, &pFrameBufferBackup); pFrameBufferBackup->Release();
		device->GetDepthStencilSurface(&pDepthBufferBackup); pDepthBufferBackup->Release();

		LPDIRECT3DSURFACE9 pSurface;
		g_pTexture->GetSurfaceLevel(0, &pSurface); 

		device->SetRenderTarget(0, pSurface);
		device->SetDepthStencilSurface(g_pDepthStencil);

		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0, 0, 200, 255), 1.0f, 0);

		RenderModelDX9(true, &vPlane);

		pSurface->Release();
		device->SetRenderTarget(0, pFrameBufferBackup);
		device->SetDepthStencilSurface(pDepthBufferBackup);
	}

	// 把上一個步驟的結果當成貼圖來使用
	{
		// 消除畫面
		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0, 0, 150, 255), 1.0f, 0);

		RenderModelDX9(false, NULL);

		Matrix4x4 identMat; identMat.Identity();
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &identMat);

		sModelMaterial_DX9 material;
		material.m_pTextures[0] = g_pTexture;
		material.Submit();

		device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_NONE);

		device->SetSamplerState(1, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(1, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
		device->SetSamplerState(1, D3DSAMP_MIPFILTER, D3DTEXF_NONE);

		Matrix4x4 uv_offset_matrix;
		uv_offset_matrix.Scale_Replace(0.5f, -0.5f, 1.0f);
		uv_offset_matrix[3].Set(0.5f, 0.5f, 0.5f, 1.0f);

		Matrix4x4 inv_view_matrix = g_Control.GetViewMatrix();
		inv_view_matrix.FastInvert();

		Matrix4x4 texture_matrix = inv_view_matrix * g_mirror_view_matrix * g_projection_matrix * uv_offset_matrix;

		device->SetTransform(D3DTS_TEXTURE0, (D3DMATRIX *) &texture_matrix);
		device->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
		// D3DTTFF_PROJECTED告知direct3d裝置texcoord需要除以w
		device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4|D3DTTFF_PROJECTED);
		float v[12];
		for ( int i=0; i<4; i++ )
		{
			g_Quad[i].m_Position.StoreXYZ(&v[i*3]);
		}
		// 畫出矩形
		device->SetFVF(D3DFVF_XYZ);
		//device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad, sizeof(Vertex_V));
		device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, v, 12);

	}

	// 宣告所有的繪圖指令都下完了
	device->EndScene(); 

	// 把背景backbuffer的畫面呈現出來
	device->Present( NULL, NULL, NULL, NULL );
}
예제 #24
0
// `使用Direct3D9來繪圖`
void RenderFrameDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();

	Matrix4x4 light_projection_matrix;
	Matrix4x4 light_view_matrix;

	Matrix4x4 view_matrix = g_Control.GetViewMatrix();
	Matrix4x4 world_matrix = g_Control.GetObjectMatrix();

	// `開始下繪圖指令`
	device->BeginScene(); 

	// `把剪影畫在動態貼圖中`
	if(1)
	{
		//! 设置临时framebuffer
		LPDIRECT3DSURFACE9 pFrameBufferBackup, pDepthBufferBackup;
		device->GetRenderTarget(0, &pFrameBufferBackup); 
		pFrameBufferBackup->Release();
		device->GetDepthStencilSurface(&pDepthBufferBackup); 
		pDepthBufferBackup->Release();

		LPDIRECT3DSURFACE9 pSurface;
		g_pTexture->GetSurfaceLevel(0, &pSurface); 

		device->SetRenderTarget(0, pSurface);
		device->SetDepthStencilSurface(g_pDepthStencil);

		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(255, 255, 255, 255), 1.0f, 0);

		Vector4 vLightPos = g_Light.m_Position;
		Vector4 vLightUp(0.0f, 1.0f, 0.0f);
		Vector4 vLightLookat(0.0f, 0.0f, 0.0f);
		// `把鏡頭放在光源的`
		light_projection_matrix = GutMatrixPerspectiveRH_DirectX(60.0f, 1.0f, 0.1f, 100.0f);
		light_view_matrix = GutMatrixLookAtRH(vLightPos, vLightLookat, vLightUp);
		// `設定轉換矩陣`
		device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&light_projection_matrix);
		device->SetTransform(D3DTS_VIEW, (D3DMATRIX *)&light_view_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *)&world_matrix);

		D3DCOLORVALUE zero = {0.0f, 0.0f, 0.0f, 1.0f};

		sModelMaterial_DX9 material;
		material.m_Material.Ambient = zero;
		material.m_Material.Emissive = zero;
		material.m_Material.Diffuse = zero;
		material.m_Material.Specular = zero;
		material.m_bCullFace = false;

		material.Submit();

		device->SetRenderState(D3DRS_LIGHTING, 0);

		g_Model_DX9.Render(0);

		pSurface->Release();
		device->SetRenderTarget(0, pFrameBufferBackup);
		device->SetDepthStencilSurface(pDepthBufferBackup);
	}

	// `把上一個步驟的結果當成貼圖來使用`
	{
		// `消除畫面`
		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0, 0, 150, 255), 1.0f, 0);
		// `設定轉換矩陣`
		device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
		device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &world_matrix);


#define DRAW_TEAPORT_FIRST 1

		//! 画茶壶
		if (DRAW_TEAPORT_FIRST)
		{
			SetupLightingDX9();
			g_Model_DX9.Render();
		}

		//! 设置矩形的纹理
		sModelMaterial_DX9 material;
		material.m_pTextures[0] = g_pTexture;
		material.Submit();

		Matrix4x4 inv_view_matrix = view_matrix;
		inv_view_matrix.FastInvert();

		Matrix4x4 uv_offset_matrix;
		uv_offset_matrix.Identity();
		uv_offset_matrix.Scale(0.5f, -0.5f, 0.5f);
		uv_offset_matrix[3].Set(0.5f, 0.5f, 0.5f, 1.0f);

		Matrix4x4 texture_matrix = inv_view_matrix * light_view_matrix * light_projection_matrix * uv_offset_matrix;
		Matrix4x4 indent_matrix = Matrix4x4::IdentityMatrix();

		device->SetTransform(D3DTS_TEXTURE0, (D3DMATRIX *) &texture_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &indent_matrix);

		device->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
		device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 |  D3DTTFF_PROJECTED );
		device->SetRenderState(D3DRS_LIGHTING, FALSE);
		// `畫出矩形`
		device->SetFVF(D3DFVF_XYZ);
		device->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2, g_Quad, sizeof(Vertex_VT));

		//! 关闭纹理矩阵
		device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);

		if (!DRAW_TEAPORT_FIRST)
		{
			//SetupLightingDX9();
			device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &world_matrix);
			g_Model_DX9.Render();
		}


	}
	// `宣告所有的繪圖指令都下完了`
	device->EndScene(); 
	// `把背景backbuffer的畫面呈現出來`
	device->Present( NULL, NULL, NULL, NULL );
}
예제 #25
0
void initD3D()
{
	d3d = Direct3DCreate9(D3D_SDK_VERSION);
	D3DPRESENT_PARAMETERS PresentParams;
	memset(&PresentParams, 0, sizeof(D3DPRESENT_PARAMETERS));

	PresentParams.Windowed = TRUE;
	PresentParams.SwapEffect = D3DSWAPEFFECT_DISCARD;

	///////////////////////////////////////////////////////////////////////

	// Set default settings
	UINT AdapterToUse = D3DADAPTER_DEFAULT;
	D3DDEVTYPE DeviceType = D3DDEVTYPE_HAL;
#ifdef SHIPPING_VERSION
	if(FAILED(d3d->CreateDevice(AdapterToUse, DeviceType, hMainWnd,
		D3DCREATE_HARDWARE_VERTEXPROCESSING,
		&PresentParams, &device)))
	{
		MessageBoxA(hMainWnd, "Unable to initialize PerfectHUD", 0, MB_ICONHAND);
		terminate();
	}
#else
	// Look for 'NVIDIA PerfHUD' adapter
	// If it is present, override default settings
	for (UINT Adapter = 0; Adapter < d3d->GetAdapterCount(); Adapter++)
	{
		D3DADAPTER_IDENTIFIER9  Identifier;
		HRESULT  Res;
		Res = d3d->GetAdapterIdentifier(Adapter, 0, &Identifier);
		if (strstr(Identifier.Description, "PerfHUD") != 0)
		{
			AdapterToUse = Adapter;
			DeviceType = D3DDEVTYPE_REF;
			break;
		}
	}
#endif

	//////////////////////////////////////////////////////////////////////

	device->SetRenderState(D3DRS_POINTSIZE_MAX, *((DWORD*)&pointSize));
	device->SetRenderState(D3DRS_POINTSIZE, *((DWORD*)&pointSize));
	device->SetRenderState(D3DRS_LIGHTING, FALSE);
	device->SetRenderState(D3DRS_POINTSPRITEENABLE, TRUE);
	device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
	device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
	device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
	device->SetRenderState(D3DRS_ZENABLE, FALSE);

	D3DXCreateTextureFromFile(device, L"particle.png", &particleTexture);
	D3DXCreateTextureFromFile(device, L"overlay.png", &overlayTexture);

	D3DXCreateTexture(device, Width, Height, 0, D3DUSAGE_RENDERTARGET, D3DFMT_X8B8G8R8, D3DPOOL_DEFAULT, &renderTexture);
	renderTexture->GetSurfaceLevel(0, &renderTarget);
	device->GetRenderTarget(0, &orig);

	//»нициализаци¤ матриц
	D3DXMATRIX matrixView;
	D3DXMATRIX matrixProjection;

	D3DXMatrixLookAtLH(
		&matrixView,
		&D3DXVECTOR3(0, 0, 0),
		&D3DXVECTOR3(0, 0, 1),
		&D3DXVECTOR3(0, 1, 0));

	D3DXMatrixOrthoOffCenterLH(&matrixProjection, 0, Width, Height, 0, 0, 255);

	device->SetTransform(D3DTS_VIEW, &matrixView);
	device->SetTransform(D3DTS_PROJECTION, &matrixProjection);

	device->SetTexture(0, particleTexture);
}
예제 #26
0
// 使用DirectX 9來繪圖
void RenderFrameDX9(void)
{
	LPDIRECT3DDEVICE9 device = GutGetGraphicsDeviceDX9();
	LPDIRECT3DTEXTURE9 pBlurredTexture = NULL;

	Matrix4x4 light_projection_matrix;
	Matrix4x4 light_view_matrix;

	Matrix4x4 view_matrix = g_Control.GetViewMatrix();
	Matrix4x4 world_matrix = g_Control.GetObjectMatrix();

	// 開始下繪圖指令
	device->BeginScene(); 
	{
		// 保存主framebuffer
		LPDIRECT3DSURFACE9 pFrameBufferBackup, pDepthBufferBackup;
		device->GetRenderTarget(0, &pFrameBufferBackup); pFrameBufferBackup->Release();
		device->GetDepthStencilSurface(&pDepthBufferBackup); pDepthBufferBackup->Release();
		// 取出動態貼圖中的surface
		LPDIRECT3DSURFACE9 pSurface;
		g_pTexture->GetSurfaceLevel(0, &pSurface); 
		// 把繪圖結果輸出到動態貼圖中
		device->SetRenderTarget(0, pSurface);
		device->SetDepthStencilSurface(g_pDepthStencil);
		// 清除畫面
		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(255, 255, 255, 255), 1.0f, 0);
		// 設定光源位置
		Vector4 vLightPos = g_Light.m_Position;
		Vector4 vLightUp(0.0f, 1.0f, 0.0f);
		Vector4 vLightLookat(0.0f, 0.0f, 0.0f);

		light_projection_matrix = GutMatrixPerspectiveRH_DirectX(60.0f, 1.0f, 0.1f, 100.0f);
		light_view_matrix = GutMatrixLookAtRH(vLightPos, vLightLookat, vLightUp);
		// 把鏡頭放到光源位置來畫陰影
		device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *)&light_projection_matrix);
		device->SetTransform(D3DTS_VIEW, (D3DMATRIX *)&light_view_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *)&world_matrix);

		// 把所有反射關閉,讓模型在畫面上呈現黑色。
		D3DCOLORVALUE zero = {0.0f, 0.0f, 0.0f, 1.0f};

		sModelMaterial_DX9 material;
		material.m_Material.Ambient = zero;
		material.m_Material.Emissive = zero;
		material.m_Material.Diffuse = zero;
		material.m_Material.Specular = zero;
		material.m_bCullFace = false;

		material.Submit();

		SetupLightingDX9();
		// 畫出模型
		g_Model_DX9.Render(0);
		// 告知direct3d9裝置rendertarget使用完畢
		pSurface->Release();
		// 還原主framebuffer
		device->SetRenderTarget(0, pFrameBufferBackup);
		device->SetDepthStencilSurface(pDepthBufferBackup);
	}

	// 把影子柔化
	{
		pBlurredTexture = BlurTexture(g_pTexture);
	}

	// 把上一個步驟的結果當成貼圖來使用
	{
		// 消除畫面
		device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_RGBA(0, 0, 150, 255), 1.0f, 0);
		// 設定轉換矩陣
		device->SetTransform(D3DTS_PROJECTION, (D3DMATRIX *) &g_projection_matrix);
		device->SetTransform(D3DTS_VIEW, (D3DMATRIX *) &view_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &world_matrix);
		// 設定光源
		SetupLightingDX9();

		device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
		device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

		device->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP);
		device->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP);

		// 畫出茶壼
		g_Model_DX9.Render();

		sModelMaterial_DX9 material;
		material.m_pTextures[0] = pBlurredTexture;
		material.Submit();
		// 計算貼圖矩陣
		Matrix4x4 inv_view_matrix = g_Control.GetCameraMatrix();
		Matrix4x4 uv_offset_matrix;
		uv_offset_matrix.Identity();
		uv_offset_matrix.Scale(0.5f, -0.5f, 0.5f);
		uv_offset_matrix[3].Set(0.5f, 0.5f, 0.5f, 1.0f);

		Matrix4x4 texture_matrix = inv_view_matrix * light_view_matrix * light_projection_matrix * uv_offset_matrix;
		Matrix4x4 indent_matrix = Matrix4x4::IdentityMatrix();
		// 設定轉換矩陣
		device->SetTransform(D3DTS_TEXTURE0, (D3DMATRIX *) &texture_matrix);
		device->SetTransform(D3DTS_WORLD, (D3DMATRIX *) &indent_matrix);
		// 開啟自動產生貼圖座標功能
		device->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, D3DTSS_TCI_CAMERASPACEPOSITION);
		device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_COUNT4 | D3DTTFF_PROJECTED);

		device->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
		device->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);

		device->SetSamplerState(1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP);
		device->SetSamplerState(1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP);

		// 畫出地表
		g_Terrain_DX9.Render(0);

		device->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, D3DTTFF_DISABLE);
		device->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
	}

	// 宣告所有的繪圖指令都下完了
	device->EndScene(); 

	// 把背景backbuffer的畫面呈現出來
	device->Present( NULL, NULL, NULL, NULL );
}
예제 #27
0
INT CrenderTarget::CreateRenderSurface()
{
	HRESULT hr=-1;

	DWORD				dMip = 1;
	LPDIRECT3DSURFACE9	pSfC = NULL;
	LPDIRECT3DSURFACE9	pSfD = NULL;
	D3DSURFACE_DESC		dscC;
	D3DSURFACE_DESC		dscD;

	D3DCAPS9			m_Caps;

	m_pDev->GetRenderTarget(0,&pSfC);
	m_pDev->GetDepthStencilSurface(&pSfD);

    pSfC->GetDesc(&dscC);
	pSfD->GetDesc(&dscD);

	m_pDev->GetDeviceCaps(&m_Caps);

	pSfC->Release();
	pSfD->Release();

	if(m_iW<0)
		m_iW = dscC.Width;
	
	if(m_iH<0)
		m_iH = dscC.Height;


	m_dC = dscC.Format;
	m_dD = dscD.Format;

	if(LCX_TARGET_HDR16 == m_nType)
		m_dC = D3DFMT_A16B16G16R16F;

	if(LCX_TARGET_HDR32 == m_nType)
		m_dC = D3DFMT_A32B32G32R32F;


	
	hr = D3DXCreateRenderToSurface(m_pDev
							, m_iW
							, m_iH
							, (D3DFORMAT)m_dC
							, TRUE
							, (D3DFORMAT)m_dD
							, &m_pRts);

	if(FAILED(hr))
		return -1;

	hr = D3DXCreateTexture(m_pDev
							, m_iW
							, m_iH
							, dMip
							, D3DUSAGE_RENDERTARGET
							, (D3DFORMAT)m_dC
							, D3DPOOL_DEFAULT
							, &m_pTxP);

	if(FAILED(hr))
        return -1;

	hr = m_pTxP->GetSurfaceLevel(0, &m_pSfc);

	if(FAILED(hr))
		return -1;

	// Clear 0x0
	m_pDev->ColorFill(m_pSfc, NULL, 0x0);
	

	return hr;
}
예제 #28
0
//-----------------------------------------------------------------------------
// Desc: 渲染图形 
//-----------------------------------------------------------------------------
VOID Render()
{
	//清空后台缓冲区
	g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(45, 50, 170), 1.0f, 0);

	//开始在后台缓冲区绘制图形
	if (SUCCEEDED(g_pd3dDevice->BeginScene()))
	{
		SetupMatrices();
		g_pd3dDevice->GetRenderTarget(0, &g_pBackupSur);
		g_pd3dDevice->SetRenderTarget(0, g_pRenderSur);
		/*RTT*/
		g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
		g_pd3dDevice->SetTexture(0, g_pTexture); //设置纹理
		g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
		g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
		D3DXSaveTextureToFileA("tt.tga", D3DXIFF_TGA, g_pRenderTex, NULL);

		D3DXMATRIXA16 matWorld1;
		D3DXMatrixIdentity(&matWorld1);
		D3DXMatrixRotationY(&matWorld1, timeGetTime() / 5000.0f);
		g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld1);

		g_pd3dDevice->SetRenderTarget(0, g_pRender2Sur);
		/*RTT*/
		g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0);
		g_pd3dDevice->SetTexture(0, g_pTexture2); //设置纹理
		g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
		g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
		D3DXSaveTextureToFileA("tt2.tga", D3DXIFF_TGA, g_pRender2Tex, NULL);

		D3DXMATRIXA16 matWorld;
		D3DXMatrixIdentity(&matWorld);
		//D3DXMatrixRotationY(&matWorld, timeGetTime() / 2000.0f);
		g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

		//创建并设置观察矩阵
		D3DXVECTOR3 vEyePt(10.0f, 0.0f, -25);
		D3DXVECTOR3 vLookatPt(10.0f, 0.0f, 0.0f);
		D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
		D3DXMATRIXA16 matView;
		D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
		g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);
		/*真是场景*/
		g_pd3dDevice->SetRenderTarget(0, g_pBackupSur);
		g_pd3dDevice->SetTexture(0, g_pRenderTex);
		g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
		g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

		g_pd3dDevice->SetTexture(0, g_pRender2Tex);
		g_pd3dDevice->SetStreamSource(0, g_pVB2, 0, sizeof(CUSTOMVERTEX));
		g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
		g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);


		//结束在后台缓冲区绘制图形
		g_pd3dDevice->EndScene();
	}

	//将在后台缓冲区绘制的图形提交到前台缓冲区显示
	g_pd3dDevice->Present(NULL, NULL, NULL, NULL);
}
예제 #29
0
// 描画
void CDOFText::Draw()
{
	LPDIRECT3DDEVICE9 lpDevice = D3D::GetDevice();

	// シーン描画開始
	D3D::Begin();

	// カメラ、投影設定
	m_Camera.SetCameraPos( &D3DXVECTOR3( 0, 0, -10 ) );
	lpDevice->SetTransform( D3DTS_VIEW, m_Camera.GetMatrix() );
	lpDevice->SetTransform( D3DTS_PROJECTION, m_Proj.GetMatrix() );

	// バックバッファ保存
	lpDevice->GetRenderTarget( 0, &m_lpBackBuffer );
	lpDevice->GetDepthStencilSurface( &m_lpZBuffer );

	CXfile::SetDrawShader( false );

	// パス1
	// テクスチャに描画
	// レンダーターゲット変更
	lpDevice->SetRenderTarget( 0, m_SceneTex.GetSurface() );
	lpDevice->SetDepthStencilSurface( m_SceneTex.GetZbuffer() );

	lpDevice->Clear(
		0,NULL,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB( 0, 0xff, 0xff ), 1.0f, 0);

	lpDevice->SetRenderState( D3DRS_FOGENABLE, TRUE );
	lpDevice->SetRenderState( D3DRS_FOGCOLOR, D3DCOLOR_XRGB( 0, 0x00, 0x80 ) );
	lpDevice->SetRenderState( D3DRS_FOGTABLEMODE, D3DFOG_LINEAR );
	lpDevice->SetRenderState( D3DRS_FOGSTART, GetAddress( 0.f ) );
	lpDevice->SetRenderState( D3DRS_FOGEND,	GetAddress( 100.f ) );

	// 描画
	CMatrix mRot, mTrans;
	mRot.SetRotY( timeGetTime() / 2 % 360 );
	
	lpDevice->SetRenderState( D3DRS_LIGHTING, TRUE );
	
	// テストメッシュ
	for( int i = 0; i < 5; i++ )
	{
		mTrans.SetTrans( -2 + i * 2, 0, -3 + i * 3 );
		lpDevice->SetTransform( D3DTS_WORLD, &(mRot * mTrans) );
		m_Mesh.Draw( lpDevice );
	}

	lpDevice->SetRenderState( D3DRS_LIGHTING, FALSE );
	lpDevice->SetTransform( D3DTS_WORLD, &CMatrix() );
	m_Sphere.Draw( lpDevice );

	// パス2
	// 縮小させる
	// レンダーターゲット変更
	// ぼかし用(ビューポートも変える)
	D3DVIEWPORT9 Vp = { 0, 0, WINDOW_WIDTH / 4, WINDOW_HEIGHT / 4, 0.f, 1.f };
	lpDevice->SetViewport( &Vp );
	lpDevice->SetRenderTarget( 0, m_MiniSizeTex.GetSurface() );
	lpDevice->SetDepthStencilSurface( m_MiniSizeTex.GetZbuffer() );

	lpDevice->Clear(
		0,NULL,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB( 0xff, 0xff, 0 ), 1.0f, 0);

	lpDevice->SetTransform( D3DTS_VIEW, &CMatrix() );
	lpDevice->SetTransform( D3DTS_PROJECTION, &CMatrix() );

	// テクスチャに描画したものを流す
	m_BlurShader.SetTexture( "g_Texture", m_SceneTex.GetTexture() );

	// 解像度を渡す
	D3DXVECTOR2 TexPos( 0.5f / Vp.Width, 0.5f / Vp.Height );
	m_BlurShader.SetValue( "g_Offset", &TexPos, sizeof(D3DXVECTOR2) );

	// シェーダー描画開始
	m_BlurShader.Begin();
	m_BlurShader.BeginPass( 0 );

	m_Scene.SetVertex( 2 );
	m_Scene.Draw( lpDevice );

	m_BlurShader.EndPass();
	m_BlurShader.End();

	// パス3
	// ぼかし入れる
	// レンダーターゲット変更
	lpDevice->SetRenderTarget( 0, m_BlurTex.GetSurface() );
	lpDevice->SetDepthStencilSurface( m_BlurTex.GetZbuffer() );
	lpDevice->SetViewport( &Vp );

	lpDevice->Clear(
		0,NULL,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB( 0xff, 0xff, 0 ), 1.0f, 0);

	// 縮小画像をシェーダーに流す
	m_BlurShader.SetTexture( "g_Texture", m_MiniSizeTex.GetTexture() );
	
	// シェーダー描画開始
	m_BlurShader.Begin();
	m_BlurShader.BeginPass( 1 );

	lpDevice->SetFVF( CBoard::FVF_VERTEX );
	m_Scene.SetVertex( 2 );
	m_Scene.Draw( lpDevice );

	m_BlurShader.EndPass();
	m_BlurShader.End();

	// パス4
	// 深度計算を行う
	// レンダーターゲット変更
	// (ビューポートももとに戻す)
	Vp.Width = WINDOW_WIDTH;
	Vp.Height = WINDOW_HEIGHT;
	lpDevice->SetViewport( &Vp );
	lpDevice->SetRenderTarget( 0, m_DepthTex.GetSurface() );
	lpDevice->SetDepthStencilSurface( m_DepthTex.GetZbuffer() );

	lpDevice->Clear(
		0,NULL,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB( 0, 0xff, 0xff ), 1.0f, 0);

	// シェーダーに値を渡す
	lpDevice->SetTransform( D3DTS_VIEW, m_Camera.GetMatrix() );
	lpDevice->SetTransform( D3DTS_PROJECTION, m_Proj.GetMatrix() );
	
	m_DepthShader.SetValue( "g_Proj",  m_Proj.GetMatrix(), sizeof(D3DXMATRIX) );
	m_DepthShader.SetValue( "g_View",  m_Camera.GetMatrix(), sizeof(D3DXMATRIX) );

	// シェーダー描画開始
	m_DepthShader.Begin();
	m_DepthShader.BeginPass( 0 );

	CXfile::SetDrawShader( true );
	//CXfile::SetShaderDevice( &m_DepthShader, "g_mWVP" );

	for( int i = 0; i < 5; i++ )
	{
		mTrans.SetTrans( -2 + i * 2, 0, -3 + i * 3 );
		lpDevice->SetTransform( D3DTS_WORLD, &(mRot * mTrans) );
		m_Mesh.Draw( lpDevice );
	}

	//m_DepthShader.SetValue( "g_World", &CMatrix(), sizeof(D3DXMATRIX) );
	lpDevice->SetTransform( D3DTS_WORLD, &CMatrix() );
	m_Sphere.Draw( lpDevice );

	m_DepthShader.EndPass();
	m_DepthShader.End();

	// パス5
	// 被写界深度適用
	// バックバッファに描画
	// バックバッファにレンダーターゲットを戻す
	lpDevice->SetRenderTarget( 0, m_lpBackBuffer );
	lpDevice->SetDepthStencilSurface( m_lpZBuffer );
	Vp.Width = WINDOW_WIDTH;
	Vp.Height= WINDOW_HEIGHT;
	lpDevice->SetViewport( &Vp );

	lpDevice->Clear(
		0,NULL,
		D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB( 0xff, 0, 0xff ), 1.0f, 0);

	// シェーダーに値を渡す
	m_DOFShader.SetTexture( "g_SceneTex", m_SceneTex.GetTexture() );	// シーン
	m_DOFShader.SetTexture( "g_BlurTex", m_BlurTex.GetTexture() );		// ぼかし
	m_DOFShader.SetTexture( "g_DepthTex", m_DepthTex.GetTexture() );	// 深度
	
	lpDevice->SetTransform( D3DTS_VIEW, &CMatrix() );
	lpDevice->SetTransform( D3DTS_PROJECTION, &CMatrix() );
	lpDevice->SetTransform( D3DTS_WORLD, &CMatrix() );

	// 板ポリゴンに描画
	m_DOFShader.Begin();
	m_DOFShader.BeginPass( 0 );

	m_Scene.SetVertex( 2 );
	m_Scene.Draw( lpDevice );

	m_DOFShader.EndPass();
	m_DOFShader.End();

	/*Vp.Y		= 300.f;
	Vp.Height	= 600.f;
	lpDevice->SetViewport( &Vp );*/

	DrawSceneByPolygon(lpDevice);

	SAFE_RELEASE( m_lpBackBuffer );
	SAFE_RELEASE( m_lpZBuffer );

	// シーン終了
	D3D::End();
}
예제 #30
0
///////////////////////////////////////////////////////////////////////
///
/// Generate a shadow map of the scene
///
void VCND3D9EffectCore::GenerateShadowMap()
{
	GPU_PROFILE_BLOCK_NAME( VCNTXT("Shadow Map") );

	HRESULT hr = S_FALSE;
	
	// Notify that we have start to render shadow map
	mGeneratingShadowMap = true;

	VCND3D9* renderer = static_cast<VCND3D9*>(VCNRenderCore::GetInstance());
	LPDIRECT3DDEVICE9 device = renderer->GetD3DDevice();

	// Keep track of the previous back buffer
	CComPtr<IDirect3DSurface9> d3dBackBuffer;
	hr = device->GetRenderTarget(0, &d3dBackBuffer);

	// Set shadow map surface and start rendering of scene using the shadow map effect
	CComPtr<IDirect3DSurface9> shadowMapSurface;
	hr = mShadowMapTexture->GetSurfaceLevel(0, &shadowMapSurface);
	VCN_ASSERT( SUCCEEDED(hr) );

	hr = device->SetRenderTarget(0, shadowMapSurface);
	VCN_ASSERT( SUCCEEDED(hr) );

	// Set the map viewport
	D3DSURFACE_DESC d3dSurfaceDesc;
	shadowMapSurface->GetDesc( &d3dSurfaceDesc );
	VCNRenderCore::GetInstance()->SetViewport(d3dSurfaceDesc.Width, d3dSurfaceDesc.Height);

	// Clear the shadow map for what's coming
	device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0, 1.0f, 0);

	// Start rendering to the map
	hr = device->BeginScene();
	VCN_ASSERT( SUCCEEDED(hr) );  
	
	device->SetRenderState(D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN);
	device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	device->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
	device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);

	// Backup current view settings
	const Matrix4 oldView = VCNXformCore::GetInstance()->GetViewMatrix();
	const Matrix4 oldProj = VCNXformCore::GetInstance()->GetProjectionMatrix();
	const VCNProjectionType oldProjType = VCNXformCore::GetInstance()->GetProjectionType();
	
	// Set the view as the light view when generating the shadow map.
	VCNLight* shadowLightSource = VCNLightingCore::GetInstance()->GetLight(0);
	const Matrix4 lightProj = shadowLightSource->GetProjectionMatrix();
	const Matrix4 lightView = shadowLightSource->GetViewMatrix();
	
	VCNXformCore::GetInstance()->SetViewLookAt( lightView );
	VCNXformCore::GetInstance()->SetProjectionMatrix( lightProj );
	
	// Draw scene
	// TODO: Generate map for each light
	VCNNodeCore::GetInstance()->GetRootNode()->Render();

	// Restore view
	VCNXformCore::GetInstance()->SetProjectionType( oldProjType, oldProj );
	VCNXformCore::GetInstance()->SetViewLookAt( oldView );

	// Restore color writes
	device->SetRenderState(D3DRS_COLORWRITEENABLE, 
		D3DCOLORWRITEENABLE_ALPHA | D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN | D3DCOLORWRITEENABLE_BLUE);

	hr = device->EndScene();
	VCN_ASSERT( SUCCEEDED(hr) );

	// Set shadow map texture for effects that needs it
	// TODO: Effects that need the shadow map should pull it from the effect core shadow maps pool
	mEffectMap[eidLitTextured]->Cast<VCND3D9_LitTexturedFX>()->SetShadowMapTexture( mShadowMapTexture );
	mEffectMap[eidSkinned]->Cast<VCND3D9_LitTexturedSkinnedFX>()->SetShadowMapTexture( mShadowMapTexture );
	mEffectMap[eidTerrain]->Cast<VCND3D9_TerrainFX>()->SetShadowMapTexture( mShadowMapTexture );

	// Restore back buffer
	device->SetRenderTarget(0, d3dBackBuffer);

	// Restore back buffer viewport
	VCNRenderCore::GetInstance()->RestoreFullViewport();

	// We are done generating shadow map
	mGeneratingShadowMap = false;
}