Beispiel #1
0
void MatrixSet()
{
	D3DXMATRIX matWorld;
	D3DXMatrixIdentity(&matWorld);
	gPD3DDevice->SetTransform(D3DTS_WORLD, &matWorld);

	D3DXMATRIX matView;
	D3DXVECTOR3 vEye(0.0f, 0.0f, -50.0f);
	D3DXVECTOR3 vAt(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 vUp(0.f, 1.f, 0.f);
	D3DXMatrixLookAtLH(&matView, &vEye, &vAt, &vUp);
	gPD3DDevice->SetTransform(D3DTS_VIEW, &matView);

	D3DXMATRIX matProj;
	D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 6.0f, 1.0f, 1.0f, 1000.0f);
	gPD3DDevice->SetTransform(D3DTS_PROJECTION, &matProj);

	D3DVIEWPORT9 viewPort;
	viewPort.Width = WINDOW_WIDTH;
	viewPort.Height = WINDOW_HEIGHT;
	viewPort.X = 0;
	viewPort.Y = 0;
	viewPort.MinZ = 0.0f;
	viewPort.MaxZ = 1.0f;
	gPD3DDevice->SetViewport(&viewPort);

}
//---------------------------------------
//NAME : SetTransform()
//DESC : 坐标转换
//---------------------------------------
void SetTransform()
{
	//设置世界变换矩阵
	D3DXMATRIX matWorld,Rx,Ry,Rz;
	D3DXMatrixIdentity(&matWorld);//单位矩阵
	D3DXMatrixRotationX(&Rx,::timeGetTime()/1000.f);//绕x轴旋转
	D3DXMatrixRotationY(&Ry,::timeGetTime()/1000.f);//绕y轴旋转
	D3DXMatrixRotationZ(&Rz,::timeGetTime()/1000.f);//绕z轴旋转

	matWorld=Rx*Ry*Rz*matWorld;
	g_pd3dDevice->SetTransform(D3DTS_WORLD,&matWorld);

	//设置取景变换矩阵
	D3DXMATRIX matView;
	D3DXVECTOR3 vEye(0.0f,0.0f,-30.0f);
	D3DXVECTOR3 vAt(0.0f,0.0f,0.0f);
	D3DXVECTOR3 vUp(0.0f,1.0f,0.0f);
	D3DXMatrixLookAtLH(&matView,&vEye,&vAt,&vUp);
	g_pd3dDevice->SetTransform(D3DTS_VIEW,&matView);

	//设置投影变换矩阵
	D3DXMATRIX matProj;
	D3DXMatrixPerspectiveFovLH(&matProj,D3DX_PI/4.0f,1.0f,1.0f,1000.0f);
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION,&matProj);
}
Beispiel #3
0
void Camera::right(){
    Vector3 vUp(up.x,up.y,up.z);
    Vector3 vEye(eye.x-look.x,eye.y-look.y,eye.z-look.z);
    Vector3 left(vUp.cross(vEye));
    eye.x+=left.x*0.03;
    eye.y+=left.y*0.03;
    eye.z+=left.z*0.03;
    look.x+=left.x*0.03;
    look.y+=left.y*0.03;
    look.z+=left.z*0.03;
}
Beispiel #4
0
/**
 *	SetCamera()
 *	カメラを設定する。
 */
void Tank::SetCamera() {
	D3DXVECTOR3 vEye(0, 10.0f, -30.0f);
	D3DXVECTOR3 vAt(0, 10.0f, 10.0f);

	D3DXMATRIX m;
	D3DXMatrixRotationY(&m, rotBody);

	D3DXVec3TransformCoord(&vEye, &vEye, &m);
	D3DXVec3TransformCoord(&vAt, &vAt, &m);

	vEye += vPos;
	vAt += vPos;

	GameMain::GetInstance().SetCamera(vEye, vAt);
}
Beispiel #5
0
void Game::Init() 
{
	m_pShaderProgram = new CShaderProgram;
	m_pSphere = new CSphere;
	m_pTimer = new CHighResolutionTimer;

	// This sets the position, viewpoint, and up vector of the synthetic camera
	glm::vec3 vEye(0, 0, 20);
	glm::vec3 vView(0, 0, 0);
	glm::vec3 vUp(0, 1, 0);
	glm::mat4 mViewMatrix = glm::lookAt(vEye, vView, vUp);

	// This creates a view frustum
	glm::mat4 mProjectionMatrix = glm::perspective(45.0f, 1.333f, 1.0f, 150.0f);

	// This sets the background colour
	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
	glClearDepth(1.0);


	// Load and compile shaders 
	CShader shVertex, shFragment;	
	shVertex.LoadShader("data\\shaders\\shader.vert", GL_VERTEX_SHADER);
	shFragment.LoadShader("data\\shaders\\shader.frag", GL_FRAGMENT_SHADER);

	// Create shader program and add shaders
	m_pShaderProgram->CreateProgram();
	m_pShaderProgram->AddShaderToProgram(&shVertex);
	m_pShaderProgram->AddShaderToProgram(&shFragment);

	// Link and use the program
	m_pShaderProgram->LinkProgram();
	m_pShaderProgram->UseProgram();

	// Set the modeling, viewing, and projection matrices in the shader
	m_pShaderProgram->SetUniform("viewMatrix", mViewMatrix);
	m_pShaderProgram->SetUniform("projectionMatrix", mProjectionMatrix);
	m_pShaderProgram->SetUniform("vlightDirection", glm::normalize(glm::vec3(0.5f, 0.5f, 0.5f)));
	m_pShaderProgram->SetUniform("sampler0", 0);

	m_pSphere->Create("data\\textures\\", "dirtpile01.jpg", 25, 25);  // Texture downloaded from http://www.psionicgames.com/?page_id=26 on 24 Jan 2013

	
	m_pTimer->Start();
}
void App::LoadTessellatedTerrain()
{
	//D3DXVECTOR3 vEye(786.1f,  -86.5f,  62.2f);
	//D3DXVECTOR3  vAt(786.3f, -130.0f, 244.1f);
	D3DXVECTOR3 vEye(18595.1f,  200.4f,  -16347.6f);
	D3DXVECTOR3  vAt(18596.1f, 200.315f, -16348.f);

	ActiveCam_->setFrom((float*)vEye);
	ActiveCam_->setTo((float*)vAt);
	ActiveCam_->setFOV(RAD2DEG(noMath::PI / 3));
	ActiveCam_->setNear(CLIP_NEAR);
	ActiveCam_->setFar(CLIP_FAR);
	ActiveCam_->SetAspect(GetAspectRatio());
	ActiveCam_->computeModelView();	
	ActiveCam_->ComputeProjection();
	
	g_ResetTerrain = true;
	ReadStars();
	
	CreateAmplifiedHeights(device);
	
	CreateShaders(device, context);
	CreateDeformEffect(device);

	// This array defines the outer width of each successive ring.
	int widths[] = { 0, 16, 16, 16, 16 };
	g_nRings = sizeof(widths) / sizeof(widths[0]) - 1;		// widths[0] doesn't define a ring hence -1
	assert(g_nRings <= MAX_RINGS);

	float tileWidth = 0.125f;
	for (int i=0; i!=g_nRings && i!=MAX_RINGS; ++i)
	{
		g_pTileRings[i] = new TileRing(device, widths[i]/2, widths[i+1], tileWidth);
		tileWidth *= 2.0f;
	}
	CreateMeshes(device, context);

	OnSizeTerrain();
}
Beispiel #7
0
//-----------------------------------------------------------------------------
// Name: RestoreDeviceObjects()
// Desc: Initialize scene objects.
//-----------------------------------------------------------------------------
HRESULT CMyD3DApplication::RestoreDeviceObjects()
{
    m_pFont->RestoreDeviceObjects();

    // Set the matrices
    D3DXVECTOR3 vEye( 0.0f, 0.0f,-3.0f );
    D3DXVECTOR3 vAt(  0.0f, 0.0f, 0.0f );
    D3DXVECTOR3 vUp(  0.0f, 1.0f, 0.0f );
    D3DXMATRIX matWorld, matView, matProj;
    D3DXMatrixIdentity( &matWorld );
    D3DXMatrixLookAtLH( &matView, &vEye,&vAt, &vUp );
    FLOAT fAspect = m_d3dsdBackBuffer.Width / (FLOAT)m_d3dsdBackBuffer.Height;
    D3DXMatrixPerspectiveFovLH( &matProj, D3DX_PI/4, fAspect, 1.0f, 100.0f );
    m_pd3dDevice->SetTransform( D3DTS_WORLD,      &matWorld );
    m_pd3dDevice->SetTransform( D3DTS_VIEW,       &matView );
    m_pd3dDevice->SetTransform( D3DTS_PROJECTION, &matProj );

    // Set state
    m_pd3dDevice->SetRenderState( D3DRS_DITHERENABLE, FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_CLIPPING,     FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_CULLMODE,     D3DCULL_NONE );
    m_pd3dDevice->SetRenderState( D3DRS_CLIPPING,     FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_LIGHTING,     FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_ZENABLE,      FALSE );
    m_pd3dDevice->SetRenderState( D3DRS_ZWRITEENABLE, FALSE );

    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLOROP,   D3DTOP_SELECTARG1 );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG1, D3DTA_TEXTURE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_COLORARG2, D3DTA_DIFFUSE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAOP,   D3DTOP_SELECTARG1 );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_ALPHAARG2, D3DTA_DIFFUSE );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
    m_pd3dDevice->SetTextureStageState( 0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );

    return S_OK;
}
Beispiel #8
0
//-----------------------------------【Matrix_Set( )函数】--------------------------------------
//	描述:封装了Direct3D四大变换的函数,即世界变换,取景变换,投影变换,视口变换的设置
//--------------------------------------------------------------------------------------------------
void Matrix_Set()
{
	//--------------------------------------------------------------------------------------
	//【四大变换之一】:世界变换矩阵的设置
	//--------------------------------------------------------------------------------------


	//--------------------------------------------------------------------------------------
	//【四大变换之二】:取景变换矩阵的设置
	//--------------------------------------------------------------------------------------
	D3DXMATRIX matView; //定义一个矩阵
	D3DXVECTOR3 vEye(0.0f, 0.0f, -50.0f);  //摄像机的位置
	D3DXVECTOR3 vAt(0.0f, 0.0f, 0.0f); //观察点的位置
	D3DXVECTOR3 vUp(0.0f, 1.0f, 0.0f);//向上的向量
	D3DXMatrixLookAtLH(&matView, &vEye, &vAt, &vUp); //计算出取景变换矩阵
	g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView); //应用取景变换矩阵

	//--------------------------------------------------------------------------------------
	//【四大变换之三】:投影变换矩阵的设置
	//--------------------------------------------------------------------------------------
	D3DXMATRIX matProj; //定义一个矩阵
	D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 4.0f, (float)((double)WINDOW_WIDTH / WINDOW_HEIGHT), 1.0f, 1000.0f); //计算投影变换矩阵
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);  //设置投影变换矩阵

	//--------------------------------------------------------------------------------------
	//【四大变换之四】:视口变换的设置
	//--------------------------------------------------------------------------------------
	D3DVIEWPORT9 vp; //实例化一个D3DVIEWPORT9结构体,然后做填空题给各个参数赋值就可以了
	vp.X = 0;		//表示视口相对于窗口的X坐标
	vp.Y = 0;		//视口相对对窗口的Y坐标
	vp.Width = WINDOW_WIDTH;	//视口的宽度
	vp.Height = WINDOW_HEIGHT; //视口的高度
	vp.MinZ = 0.0f; //视口在深度缓存中的最小深度值
	vp.MaxZ = 1.0f;	//视口在深度缓存中的最大深度值
	g_pd3dDevice->SetViewport(&vp); //视口的设置

}
void Matrix_Set()
{
	D3DXMATRIX matView;
	D3DXVECTOR3 vEye(0.0f, 100.0f, -200.0f);
	D3DXVECTOR3 vAt(0.0f, 30.0f, 0.0f);
	D3DXVECTOR3 vUp(0.0f, 1.0f, 0.0f);
	D3DXMatrixLookAtLH(&matView, &vEye, &vAt, &vUp);
	g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);

	D3DXMATRIX matProj;
	D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / 4.0f, (float)WINDOW_WIDTH / (float)WINDOW_HEIGHT, 1.0f, 10000.0f);
	g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);

	D3DVIEWPORT9 vp;

	vp.X = 0;
	vp.Y = 0;
	vp.Width = WINDOW_WIDTH;
	vp.Height = WINDOW_HEIGHT;
	vp.MinZ = 0.0f;
	vp.MaxZ = 1.0f;

	g_pd3dDevice->SetViewport(&vp);
}
Beispiel #10
0
/*!
 	MyApp::DrawFrame()
 */
void MyApp::DrawFrame()
{
	//// シーンアップデート

	// シーンクリア
	_device.GetInterface()->Clear(
		0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER,
		D3DCOLOR_XRGB(0,0,80), 1.0f, 0);

	// シーン描画開始
	HRESULT hr = _device.GetInterface()->BeginScene();
	if (SUCCEEDED(hr)) {
		//// シーン描画
		
		// ビュー変換
		D3DXMATRIX mView;
		D3DXVECTOR3 vEye(0.0f, 2.0f, -5.0f);
		D3DXVECTOR3 vAt(0.0f, 0.0f ,0.0f);
		D3DXVECTOR3 vUp(0.0f, 1.0f, 0.0f);
		D3DXMatrixLookAtLH(&mView, &vEye, &vAt, &vUp);
		_device.GetInterface()->SetTransform(D3DTS_VIEW, &mView);
		
		// 射影変換
		D3DXMATRIX mProj;
		D3DXMatrixPerspectiveFovLH(&mProj,
			FOV_ANGLE,
			(float)SCREEN_W/(float)SCREEN_H,
			NEAR_Z, FAR_Z);
		_device.GetInterface()->SetTransform(D3DTS_PROJECTION, &mProj);

		// ワールド変換
		D3DXMATRIX mWorld, mRot, mKuti;
		D3DXMatrixIdentity(&mWorld);
		
		mWorld *= *D3DXMatrixRotationY(&mKuti, D3DXToRadian(-90));	// 口の向きを(1,0,0)にしたいので-90度回転
		
		mWorld *= *D3DXPlus::MatrixRotationVector(&mRot, &_vRotation);


		_device.GetInterface()->SetTransform(D3DTS_WORLD, &mWorld);

		// メッシュ描画
		_mesh.Render(_device);

		// 向き描画
		D3DXPlus::DrawLine(_device.GetInterface(), D3DXVECTOR3(0,0,0), _vRotation * 2.0f, 
			D3DCOLOR_XRGB(0xff, 0x00, 0xff), D3DCOLOR_XRGB(0x00, 0xff, 0xff));

		if (_bTurning) {
			D3DXPlus::DrawLine(_device.GetInterface(), D3DXVECTOR3(0,0,0), _vTurn * 2.0f, 
				D3DCOLOR_XRGB(0xff, 0x00, 0xff), D3DCOLOR_XRGB(0xff, 0xff, 0x00));
		}

		// シーン描画終了
		_device.GetInterface()->EndScene();
	}

	// シーンの表示
	hr = _device.GetInterface()->Present(NULL, NULL, NULL, NULL);
	if (hr == D3DERR_DEVICELOST) ;
}
Beispiel #11
0
void DCRenderer::Draw(f32 fDeltaTime)
{	
    // For our world matrix, we will just rotate the object about the y-axis.
    D3DXMATRIXA16 mxView, mxProj;

    D3DXVECTOR3 vEye(0.0f, 5.0f,-5.0f);
    D3DXVECTOR3 vAt(0.0f,0.0f,1.0f);
    D3DXVECTOR3 vUp(0.0f,1.0f,0.0f);

    float fAspectRatio = m_pRenderWidget->width() / (FLOAT)m_pRenderWidget->height();

    D3DXMatrixLookAtLH(&mxView, &vEye, &vAt, &vUp);
    D3DXMatrixPerspectiveFovLH(&mxProj, D3DX_PI/3, fAspectRatio, 0.001f, 100.0f);

 	//models
	// For our world matrix, we will just rotate the object about the y-axis.
	D3DXMATRIXA16 mxWorld, mxViewProj;

	D3DXMatrixIdentity(&mxViewProj);

	BM_AssertHr(DEVICEPTR->BeginScene());	
	{        
		BeginRender();
		DEVICEPTR->Clear( 0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,D3DCOLOR_COLORVALUE(85.0f/255.0f,101.0f/255.0f,215.0f/255.0f,1.0f), 1.0f, 0 );
		BM_AssertHr(DEVICEPTR->EndScene());    

		//models		
		const std::vector<BatchNode>& nodes = BatchNodes;
		const u32 nodeNum = nodes.size();
		for(u32 nodeIdx = 0; nodeIdx<nodeNum; nodeIdx++)
		{
			BM_AssertHr(DEVICEPTR->BeginScene());
			const BatchNode& nodePtrRef = nodes[nodeIdx];
			const XMFLOAT3& translation = nodePtrRef.translation;
			D3DXMatrixTranslation(&mxWorld, translation.x, translation.y, translation.z);
			mxViewProj = mxView * mxProj;

			DEVICEPTR->SetVertexShaderConstantF(0,(float*)&(mxWorld),4);
			DEVICEPTR->SetVertexShaderConstantF(4,(float*)mViewProjMatrix,4);
			DEVICEPTR->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
			DEVICEPTR->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

			nodePtrRef.model->Draw(0);
			BM_AssertHr(DEVICEPTR->EndScene()); 
		}

		BM_AssertHr(DEVICEPTR->BeginScene());

		//terrain		
		if(TerrainPtr)
		{
			TerrainPtr->Draw(&mxWorld, (D3DXMATRIXA16*)mViewMatrix, (D3DXMATRIXA16*)mProjMatrix);
		}

		BMPostFXRenderer::GetInstance()->Render();

		EndRender();
		BM_AssertHr(DEVICEPTR->EndScene()); 
	}

	BatchNodes.clear();
}
//--------------------------------------------------------------------------------------
// Create any D3D10 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D10CreateDevice( ID3D10Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
                                      void* pUserContext )
{
    HRESULT hr;

    V_RETURN( g_DialogResourceManager.OnD3D10CreateDevice( pd3dDevice ) );
    V_RETURN( g_D3DSettingsDlg.OnD3D10CreateDevice( pd3dDevice ) );
    V_RETURN( D3DX10CreateFont( pd3dDevice, 15, 0, FW_BOLD, 1, FALSE, DEFAULT_CHARSET,
                                OUT_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH | FF_DONTCARE,
                                L"Arial", &g_pFont10 ) );
    V_RETURN( D3DX10CreateSprite( pd3dDevice, 512, &g_pSprite10 ) );
    g_pTxtHelper = new CDXUTTextHelper( NULL, NULL, g_pFont10, g_pSprite10, 15 );

    V_RETURN( CDXUTDirectionWidget::StaticOnD3D10CreateDevice( pd3dDevice ) );

    // Read the D3DX effect file
    WCHAR str[MAX_PATH];
    V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"MotionBlur10.fx" ) );
    DWORD dwShaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
    // Set the D3D10_SHADER_DEBUG flag to embed debug information in the shaders.
    // Setting this flag improves the shader debugging experience, but still allows 
    // the shaders to be optimized and to run exactly the way they will run in 
    // the release configuration of this program.
    dwShaderFlags |= D3D10_SHADER_DEBUG;
    #endif
    V_RETURN( D3DX10CreateEffectFromFile( str, NULL, NULL, "fx_4_0", dwShaderFlags, 0, pd3dDevice, NULL,
                                              NULL, &g_pEffect, NULL, NULL ) );

    // Obtain the technique handles
    g_pRenderScene = g_pEffect->GetTechniqueByName( "RenderScene" );
    g_pRenderSkinnedScene = g_pEffect->GetTechniqueByName( "RenderSkinnedScene" );
    g_pRenderMotionBlur = g_pEffect->GetTechniqueByName( "RenderMotionBlur" );
    g_pRenderSkinnedMotionBlur = g_pEffect->GetTechniqueByName( "RenderSkinnedMotionBlur" );

    // Obtain the parameter handles
    g_pmWorldViewProj = g_pEffect->GetVariableByName( "g_mWorldViewProj" )->AsMatrix();
    g_pmViewProj = g_pEffect->GetVariableByName( "g_mViewProj" )->AsMatrix();
    g_pmWorldView = g_pEffect->GetVariableByName( "g_mWorldView" )->AsMatrix();
    g_pmBlurViewProj = g_pEffect->GetVariableByName( "g_mBlurViewProj" )->AsMatrix();
    g_pmBlurWorld = g_pEffect->GetVariableByName( "g_mBlurWorld" )->AsMatrix();
    g_pmBoneWorld = g_pEffect->GetVariableByName( "g_mBoneWorld" )->AsMatrix();
    g_ptxDiffuse = g_pEffect->GetVariableByName( "g_txDiffuse" )->AsShaderResource();
    g_pfFrameTime = g_pEffect->GetVariableByName( "g_fFrameTime" )->AsScalar();
    g_piNumSteps = g_pEffect->GetVariableByName( "g_iNumSteps" )->AsScalar();
    g_pfFadeDist = g_pEffect->GetVariableByName( "g_fFadeDist" )->AsScalar();

    // Define our vertex data layout
    const D3D10_INPUT_ELEMENT_DESC staticlayout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 32, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    };

    D3D10_PASS_DESC PassDesc;
    g_pRenderScene->GetPassByIndex( 0 )->GetDesc( &PassDesc );
    V_RETURN( pd3dDevice->CreateInputLayout( staticlayout, 4, PassDesc.pIAInputSignature,
                                             PassDesc.IAInputSignatureSize, &g_pStaticVertexLayout ) );

    //Create the scene meshes
    g_SceneMesh.Create( pd3dDevice, L"motionblur\\WindMillStage.sdkmesh" );
    g_FanMesh.Create( pd3dDevice, L"motionblur\\Fan.sdkmesh" );
    D3DXMatrixTranslation( &g_mFanWorld, 0.0f, 3.62f, 2.012f );

    //Create the Linked Meshes
    g_pLinkedMeshes = new CDXUTSDKMesh[ g_NumLinkedMeshes ];
    if( !g_pLinkedMeshes )
        return E_OUTOFMEMORY;
    for( UINT iMesh = 0; iMesh < g_NumLinkedMeshes; iMesh++ )
    {
        g_pLinkedMeshes[iMesh].Create( pd3dDevice, g_MeshLinkages[iMesh].szMeshName );
    }

    const D3D10_INPUT_ELEMENT_DESC skinnedlayout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 24, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 32, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "BONES", 0, DXGI_FORMAT_R32G32B32A32_UINT, 0, 44, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        { "WEIGHTS", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 60, D3D10_INPUT_PER_VERTEX_DATA, 0 },
    };

    g_pRenderSkinnedScene->GetPassByIndex( 0 )->GetDesc( &PassDesc );
    V_RETURN( pd3dDevice->CreateInputLayout( skinnedlayout, 6, PassDesc.pIAInputSignature,
                                             PassDesc.IAInputSignatureSize, &g_pSkinnedVertexLayout ) );
    g_AnimMesh.Create( pd3dDevice, L"motionblur\\Warrior.sdkmesh" );
    g_AnimMesh.LoadAnimation( L"motionblur\\Warrior.sdkmesh_anim" );

    //camera
    D3DXVECTOR3 vEye( 2.0f, 1.3f, -4.0f );
    D3DXVECTOR3 vAt( 0.0f, 1.0f, -1.11f );
    g_Camera.SetViewParams( &vEye, &vAt );

    return S_OK;
}
HRESULT DXSourceWindow::Render(BufferQueue* pSyncBuffer,unsigned int uiTransferId)
{

	DXcopyApp::FrameData* pFrame = NULL;
    unsigned int uiBufferIdx = pSyncBuffer->getBufferForWriting((void*&)pFrame);

	//change the fill color
	float clearColorSource[4] = { m_clearColorR, m_clearColorG, m_clearColorB, 1.0f }; //red,green,blue,alpha

	//fill the backbuffer of the Source with 'clearColorR'
	m_pImmediateContext->ClearRenderTargetView( m_pBackBuffer_RTV, clearColorSource );
	m_pImmediateContext->ClearDepthStencilView( m_pDSV, D3D11_CLEAR_DEPTH, 1.0, 0 ); 


	D3DXMATRIX mWorldViewProjection;
	D3DXMATRIX mWorldView;
    D3DXMATRIX mWorld;
    D3DXMATRIX mView;
    D3DXMATRIX mProj;
    
    // Set the per object constant data
	D3DXMatrixRotationAxis( &mWorld, &D3DXVECTOR3(1,1,1), m_Cube_angle  );
	
	m_Cube_angle += 0.04f * 0.01745f;
	
	if (m_Cube_angle >= 2.0f*3.1415926f) { m_Cube_angle = 0.0f; }

	D3DXVECTOR3 vEye( 0.0f, 0.0f, 2.0f );
	D3DXVECTOR3 vLook( 0.0f,0.0f,0.0f ); 
	D3DXVECTOR3 vUp( 0.0f,1.0f,0.0f );
	D3DXMatrixLookAtLH( &mView, &vEye, &vLook, &vUp );
	
	D3DXMatrixPerspectiveFovLH(&mProj, 3.1415926f/4.0f,  (float)DXwindow::m_width/(float)DXwindow::m_height,    0.1f, 10.0f);
	
	mWorldViewProjection = mWorld * mView * mProj;
	mWorldView			 = mWorld * mView;

	D3D11_MAPPED_SUBRESOURCE MappedResource;
	m_pImmediateContext->Map( m_Cube_pcb, 0, D3D11_MAP_WRITE_DISCARD, 0, &MappedResource );
	CUBE_CB* pCB = ( CUBE_CB* )MappedResource.pData;
	D3DXMatrixTranspose( &pCB->f4x4WorldViewProjection, &mWorldViewProjection );
	D3DXMatrixTranspose( &pCB->f4x4WorldView, &mWorldView );
	m_pImmediateContext->Unmap( m_Cube_pcb, 0 );

	m_pImmediateContext->VSSetConstantBuffers( 0, 1, &m_Cube_pcb );
	m_pImmediateContext->PSSetConstantBuffers( 0, 1, &m_Cube_pcb );

	m_pImmediateContext->VSSetShader( m_Cube_pVertexShader, NULL, 0 );
	m_pImmediateContext->PSSetShader( m_Cube_pPixelShader, NULL, 0 );

	m_pImmediateContext->IASetInputLayout( m_Cube_pVertexLayout11 );
	m_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	UINT Stride = sizeof( CUBE_Vertex1 );
	UINT Offset = 0;
	m_pImmediateContext->IASetVertexBuffers( 0, 1, &m_Cube_pVertexBuffer, &Stride, &Offset );
	m_pImmediateContext->IASetIndexBuffer( m_Cube_pIndexBuffer, DXGI_FORMAT_R32_UINT, 0 );
	m_pImmediateContext->PSSetShaderResources( 0, 1, &m_Cube_pTextureRV );
	m_pImmediateContext->PSSetSamplers( 0, 1, &m_Cube_pSamplerLinear );
	m_pImmediateContext->DrawIndexed( 36, 0, 0 );


	// update frame data
	pFrame->uiTransferId = uiTransferId;

	m_pImmediateContext->CopyResource(m_source_SDItexture[uiBufferIdx], m_pBackBuffer );
	AmdDxMarkerInfo   m_pInfo;
	m_pInfo.markerValue = pFrame->uiTransferId;
	m_pInfo.markerOffset = pFrame->ullMarkerBusAddress & 0xfff;
 
	BOOL WriteMarkerSuccess = m_pSDI->WriteMarker11(m_source_SDItexture[uiBufferIdx], &m_pInfo);
	if ( !WriteMarkerSuccess ) { PASS_TEST(E_FAIL) }
 
	// This Flush() call is not necessary but with this one, the performance will be much better.
	m_pImmediateContext->Flush();
	pSyncBuffer->releaseWriteBuffer();
	m_pSwapChain->Present(0,0);


	return S_OK;
}