Beispiel #1
0
void CALLBACK OnFrameMove(_In_ double fTime, _In_ float fElapsedTime, _In_opt_ void* pUserContext)
{
	static float rot = 0.0f;
	rot += fElapsedTime;
	XMMATRIX mscale = XMMatrixScaling(1.0f, 1.0f, 1.0f);
	XMMATRIX mrot	= XMMatrixRotationRollPitchYaw(0.0f, 0.0f, rot);
	XMMATRIX mtrans = XMMatrixTranslation(20.0f, 50.0f, 0.0f);

	// gmesh 의 월드 매트릭스 -> XMMATRIX
	XMMATRIX mParent = XMLoadFloat4x4(&g_mesh->getWorld());

	g_matLight = (mscale * mtrans * mrot) * mParent;
	
	// 조명 메시 연결
	XMFLOAT4X4 mlit = XMFLOAT4X4();
	XMStoreFloat4x4(&mlit, g_matLight);
	g_meshLight->setWorld(mlit);


	g_camera.FrameMove(fElapsedTime);




}
	void ProxyModel::Draw(const GameTime& gameTime)
	{
		ID3D11DeviceContext* direct3DDeviceContext = mGame->GetD3DDeviceContext();			
		direct3DDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
		direct3DDeviceContext->IASetInputLayout(mInputLayout.Get());

		UINT stride = sizeof(VertexPositionColorAlpha);
		UINT offset = 0;
		direct3DDeviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &offset);
		direct3DDeviceContext->IASetIndexBuffer(mIndexBuffer.Get(), DXGI_FORMAT_R32_UINT, 0);

		direct3DDeviceContext->VSSetShader(mVertexShader.Get(), nullptr, 0);
		direct3DDeviceContext->PSSetShader(mPixelShader.Get(), nullptr, 0);

		XMMATRIX worldMatrix = XMLoadFloat4x4(&mWorldMatrix);
		XMMATRIX wvp = worldMatrix * mCamera->ViewProjectionMatrix();
		XMStoreFloat4x4(&mVertexCBufferPerObjectData.WorldViewProjection, XMMatrixTranspose(wvp));

		direct3DDeviceContext->UpdateSubresource(mVertexCBufferPerObject.Get(), 0, nullptr, &mVertexCBufferPerObjectData, 0, 0);
		direct3DDeviceContext->VSSetConstantBuffers(0, 1, mVertexCBufferPerObject.GetAddressOf());

		if (mDisplayWireframe)
		{
			mGame->GetD3DDeviceContext()->RSSetState(RasterizerStates::Wireframe.Get());
			direct3DDeviceContext->DrawIndexed(mIndexCount, 0, 0);
			mGame->GetD3DDeviceContext()->RSSetState(nullptr);
		}
		else
		{
			direct3DDeviceContext->DrawIndexed(mIndexCount, 0, 0);
		}
	}
	void KungFuPOC::UpdateKinectSkeletonData()
	{
		float3 offset(0.0, 0.0, 0.0);
		
		SkeletonData data;
		kinectController.GetSkeletonData(&data);
		int skeletonIndex = GetActiveSkeleton(data.skeletonData);
		if (skeletonIndex < 0) return;

		NUI_SKELETON_DATA skeleton = data.skeletonData[skeletonIndex];
		Vector4* positions = skeleton.SkeletonPositions;
		
		float dz = 0.0;
		for (int i = 0; i != NUI_SKELETON_POSITION_COUNT; ++i) {			
			Vector4& pos = positions[i];
			pos.z = -pos.z;
			// don't let player come too close to the painting!
			if (i == 0) {
				if (pos.z > PAINTING_Z - MINIMUM_PLAYER_DISTANCE) {
					dz = pos.z - (PAINTING_Z - MINIMUM_PLAYER_DISTANCE);
				}
			}
			pos.z -= dz;
		}

		stickFigureMesh->Update(deviceContext, positions);

		matrix4x4 projectionMtx = XMLoadFloat4x4(&projection);
		for (auto it = paintLogics.begin(); it != paintLogics.end(); ++it) {
			deviceContext->OMSetRenderTargets(1, &backBufferView, depthStencilView);
			SetViewport(0, 0, (float)windowWidth, (float)windowHeight);
			(*it)->Update(projectionMtx, deviceContext, positions);
		}
	}
void cGridMesh::Draw()
{
	// Set Layout And Topology
	g_pD3DDC->IASetInputLayout(cInputLayouts::Simple);
	g_pD3DDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

	// Set VertexBuffer And IndexBuffer
	UINT stride = sizeof(Vertex::Simple);
	UINT offset = 0;
	g_pD3DDC->IASetVertexBuffers(0, 1, &m_VB, &stride, &offset);
	g_pD3DDC->IASetIndexBuffer(m_IB, DXGI_FORMAT_R32_UINT, 0);

	// worldViewProj Çà·ÄÀ» ±¸ÇÑ´Ù.
	XMMATRIX world	= XMLoadFloat4x4(&GetTransformMatrix());
	XMMATRIX view	= g_pCameraManager->GetView();
	XMMATRIX proj	= g_pCameraManager->GetProj();
	XMMATRIX worldViewProj = world * view * proj;

	// ¼ÎÀÌ´õ¿¡ »ó¼ö°ª ¼³Á¤.
	cEffects::SimpleFX->SetWorldViewProj(worldViewProj);

	ID3DX11EffectTechnique* tech = cEffects::SimpleFX->ColorTech;
	D3DX11_TECHNIQUE_DESC techDesc;
	tech->GetDesc(&techDesc);
	for (UINT p = 0; p < techDesc.Passes; ++p)
	{
		tech->GetPassByIndex(p)->Apply(0, g_pD3DDC);

		// »öÀÎÀ» »ç¿ëÇؼ­ ±×¸°´Ù.
		g_pD3DDC->DrawIndexed(m_GridIndexCount, 0, 0);
	}

	HR(g_pD3DSC->Present(0, 0));
}
Beispiel #5
0
void CPlayer::RotateY(float fAngle)
{
    XMMATRIX matRotY = XMMatrixRotationY(fAngle);
    //CXMMATRIX 형식으로 바꿀 필요 있음.
    XMMATRIX matWorld = XMLoadFloat4x4( &m_matWorld );
    XMStoreFloat4x4( &m_matWorld , XMMatrixMultiply( matWorld , matRotY) );
}
void RenderSystem::CheckPick()
{
	float tempDist;
	float closestDist = FLT_MAX;
	int hitIndex;
	float pickedDist = 0;

	XMMATRIX Proj      = XMMatrixPerspectiveFovLH(0.4f*3.14f, GetAspect(), 1.0f, 1000.0f);
	d3dPicking.PickRayVector(m_Camera.GetMouseX(), m_Camera.GetMouseY(), XMLoadFloat4x4(&m_Camera.GetViewMatrix()), Proj);

	//Check if picking the object and mark it
	for (int i = 0; i < 20; i++)
	{
		if (bottleHit[i] == 0) //No need to check bottles already hit
		{
			tempDist = d3dPicking.Pick(bottleModel[i]);
			if (tempDist < closestDist)
			{
				closestDist = tempDist;
				hitIndex = i;
			}
		}
	}

	//We pick a object, and set the closest one be the target object
	if (closestDist < FLT_MAX)
	{
		bottleHit[hitIndex] = 1;
		pickedDist = closestDist;
		++score;
	}

}
void Simulation::Draw()
{
	m_Camera.UpdateViewMatrix();

	XMStoreFloat4x4(&(matrixBufferData.view), XMMatrixTranspose(m_Camera.View()));
	
	const float clearColor[4] = { 0.0f, 0.0, 0.0f, 1.0f };

	devCon->ClearRenderTargetView(renderTargetView, clearColor);
	devCon->ClearDepthStencilView(depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);

	float blendFactors[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
	devCon->OMSetBlendState(blendState, blendFactors, 0xFFFFFF);

	devCon->IASetInputLayout(inputLayout);
	devCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	devCon->VSSetConstantBuffers(0, 1, &matrixBuffer);
	devCon->OMSetDepthStencilState(depthStencilState, 0);

	for (GameObject* obj : objects)
	{
		devCon->RSSetState(current);
		XMStoreFloat4x4(&(matrixBufferData.world), XMLoadFloat4x4(&(obj->GetWorldMatrix())));
		devCon->UpdateSubresource(matrixBuffer, 0, NULL, &matrixBufferData, 0, 0);
		obj->Draw(devCon);
	}
	
	swapChain->Present(0, 0);
}
void Entity::Draw2D(ID3DX11EffectTechnique* activeTech, ID3D11DeviceContext* context, UINT pass, const Camera& camera, XMMATRIX& ortho)
{
	XMMATRIX world = XMLoadFloat4x4(&mWorld);
	XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);

	XMMATRIX worldViewProj = world*ortho;
	Effects::BasicFX->SetWorld(world);
	Effects::BasicFX->SetWorldInvTranspose(worldInvTranspose);
	Effects::BasicFX->SetWorldViewProj(worldViewProj);

	if (!useTexTrans){ Effects::BasicFX->SetTexTransform(XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z)); }
	if (mBasicTexTrans)
	{
		XMMATRIX Scale;
		mFlipTexture ? Scale = XMMatrixScaling(-origTexScale.x, origTexScale.y, origTexScale.z) : Scale = XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z);
		Effects::BasicFX->SetTexTransform(XMMatrixTranslation(texTrans.x, texTrans.y, texTrans.z)*Scale);
	}
	if (mUseAnimation)
	{
		XMMATRIX Scale;
		mAnim->Flipped() ? Scale = XMMatrixScaling(-origTexScale.x, origTexScale.y, origTexScale.z) : Scale = XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z);
		Effects::BasicFX->SetTexTransform(XMMatrixTranslation(mAnim->GetX(), mAnim->GetY(), texTrans.z)*Scale);
	}
	Effects::BasicFX->SetMaterial(mMat);
	Effects::BasicFX->SetDiffuseMap(mTexSRV);

	activeTech->GetPassByIndex(pass)->Apply(0, context);
	context->DrawIndexed(mIndexCount, mIndexOffset, mVertexOffset);
}
Beispiel #9
0
void Transform::UpdateCBuffer()
{
	//updatesubresource med den nya transformData
	XMMATRIX tempWorld = XMMatrixIdentity();

	XMMATRIX tempScale = XMMatrixIdentity();
	XMMATRIX tempRotation = XMMatrixIdentity();
	XMMATRIX tempPosition = XMMatrixIdentity();

	tempScale = XMMatrixScaling(transformData.scale.x, transformData.scale.y, transformData.scale.z);
	//XMMatrixRotationQuaternion använd en quaternion istället! cool stuff, sen bör det funka
	//transformData.pos.z = transformData.pos.z * -1.0f;
	//transformData.rot.x = transformData.rot.x * -1.0f;
	//transformData.rot.y = transformData.rot.y * -1.0f;
	XMVECTOR rotationQuat = XMVectorSet(transformData.rot.x, transformData.rot.y, transformData.rot.z, transformData.rot.w);
	tempRotation = XMMatrixRotationQuaternion(rotationQuat);
	tempPosition = XMMatrixTranslation(transformData.pos.x, transformData.pos.y, transformData.pos.z);

	tempWorld = tempRotation * tempScale * tempPosition;
	if (parent != nullptr)
	{
		parent->UpdateCBuffer();
		XMMATRIX parentWorld = XMLoadFloat4x4(&parent->transformCBufferData.world);
		tempWorld = tempWorld /** parentWorld*/;
	}

	XMStoreFloat4x4(&transformCBufferData.world, XMMatrixTranspose(tempWorld));
	//transformdata ligger på plats 0, material på 1, osv
	gDeviceContext->UpdateSubresource(transformCBuffer, 0, NULL, &transformCBufferData.world, 0, 0); //skapa en separat struct för transformdata som ska in i shadern, world osv
	gDeviceContext->VSSetConstantBuffers(0, 1, &transformCBuffer);
}
Beispiel #10
0
void LevelParts::setWorld(XMFLOAT4X4 tempLevelPartsWorld)
{


	mLevelPartsWorld = tempLevelPartsWorld;


	XMMATRIX tempWorld = XMLoadFloat4x4(&mLevelPartsWorld);


	XMVECTOR Scale;
	XMVECTOR Position;
	XMVECTOR Rotation;


	XMMatrixDecompose(&Scale, &Rotation, &Position, tempWorld);

	XMStoreFloat3(&mLevelPartsPosition, Position);

	XMStoreFloat3(&mLevelPartsScale, Scale);

	XMStoreFloat4(&mLevelPartsRotation, Rotation);





	XMVECTOR S = XMLoadFloat3(&mLevelPartsScale);
	XMVECTOR P = XMLoadFloat3(&mLevelPartsPosition);
	XMVECTOR Q = XMLoadFloat4(&mLevelPartsRotationQuad);
	XMVECTOR rot = XMLoadFloat4(&mLevelPartsRotation);

	XMStoreFloat4x4(&mLevelPartsStartingWorld, XMMatrixAffineTransformation(S, rot, Q, P));

}
Beispiel #11
0
void InClassProj::DrawParticles()
{
	XMVECTOR eyePos = m2DCam->GetPos();
	XMMATRIX proj = XMLoadFloat4x4(&mProj);
	XMMATRIX view = m2DCam->GetView();

	XMMATRIX vp = view * proj;

	mParticleEffect->SetPerFrameParams(eyePos);
	mParticleEffect->SetPerObjectParams(vp, mParticleTexture);

	md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
	md3dImmediateContext->IASetInputLayout(Vertex::GetParticleVertLayout());
	
	UINT stride = sizeof(Vertex::ParticleVertex);
	UINT offset = 0;

	md3dImmediateContext->IASetVertexBuffers(0, 1, &mParticleVB, &stride, &offset);
	
	md3dImmediateContext->OMSetDepthStencilState(mNoDepthDS, 0);
	float blendFactor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
	md3dImmediateContext->OMSetBlendState(mAdditiveBS, blendFactor, 0xffffffff);

	D3DX11_TECHNIQUE_DESC techDesc; 
	mParticleEffect->GetTech()->GetDesc(&techDesc);
	for (UINT p = 0; p < techDesc.Passes; ++p)
	{
		mParticleEffect->GetTech()->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
		md3dImmediateContext->Draw(mParticles.size(), 0);
	}

	md3dImmediateContext->OMSetBlendState(0, blendFactor, 0xffffffff);
	md3dImmediateContext->OMSetDepthStencilState(NULL, 0);
}
void Enemies::update(float dt)
{



	DeltaTime = dt;

	for (int i = 0; i < mEnemyInstances.size(); i++)
	{

		enemyclass[i]->update(DeltaTime);

		mEnemyInstances[i].World = enemyclass[i]->GetWorld();

		XMMATRIX temp = XMLoadFloat4x4(&mEnemyInstances[i].World);
		XMVECTOR Scale;
		XMVECTOR Rotation;
		XMVECTOR Position;

		XMFLOAT3 tempPosition;

		XMMatrixDecompose(&Scale, &Rotation, &Position, temp);
		XMStoreFloat3(&tempPosition, Position);



		LevelCollisions[i].Center = tempPosition;


	}

}
Beispiel #13
0
void LightHandler::Draw(TerrainEntity* terrain, ID3D11DeviceContext* devCon, Camera* camera)
{
	devCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	devCon->IASetInputLayout(InputLayouts::mPos);
	
	this->mShadowMap->BindDSVAndSetRTV(devCon);
	this->mShadowMap->ResetMap();

	Effects::TerrainFX->SetShadowMap(this->mShadowMap->GetDepthSRV());

	XMMATRIX lightVP = XMMatrixMultiply(this->CalcView(camera), this->CalcProj(camera));

	Effects::TerrainFX->SetLightVP(lightVP);
	Effects::ShadowFX->SetLightVP(lightVP);

	D3DX11_TECHNIQUE_DESC techDesc = {};
	Effects::ShadowFX->mShadowTech->GetDesc(&techDesc);

	for(UINT i(0); i != techDesc.Passes; ++i)
	{
		Effects::ShadowFX->SetWorld(XMLoadFloat4x4(&terrain->GetInstance()->mWorld));

		Effects::ShadowFX->mShadowTech->GetPassByIndex(i)->Apply(0, devCon);
		terrain->GetInstance()->mModel->GetMesh()->Draw(devCon);
	}
}
Beispiel #14
0
	//---------------------------------------------------------------------
	void Frustum::setViewParams(FXMVECTOR pos, FXMVECTOR lookAt, FXMVECTOR upDir)
	{
		XMStoreFloat4x4(&mViewMatrix, XMMatrixLookAtLH(pos, lookAt, upDir));
		XMStoreFloat4x4(&mViewProjMatrix, XMLoadFloat4x4(&mViewMatrix) * XMLoadFloat4x4(&mProjMatrix));

		/// front
		mPlanes[FS_FRONT].x = mViewProjMatrix._14 + mViewProjMatrix._13;
		mPlanes[FS_FRONT].y = mViewProjMatrix._24 + mViewProjMatrix._23;
		mPlanes[FS_FRONT].z = mViewProjMatrix._34 + mViewProjMatrix._33;
		mPlanes[FS_FRONT].w = mViewProjMatrix._44 + mViewProjMatrix._43;
		XMStoreFloat4(&mPlanes[FS_FRONT], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_FRONT])));

		/// back
		mPlanes[FS_BACK].x = mViewProjMatrix._14 - mViewProjMatrix._13;
		mPlanes[FS_BACK].y = mViewProjMatrix._24 - mViewProjMatrix._23;
		mPlanes[FS_BACK].z = mViewProjMatrix._34 - mViewProjMatrix._33;
		mPlanes[FS_BACK].w = mViewProjMatrix._44 - mViewProjMatrix._43;
		XMStoreFloat4(&mPlanes[FS_BACK], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_BACK])));

		/// left
		mPlanes[FS_LEFT].x = mViewProjMatrix._14 + mViewProjMatrix._11;
		mPlanes[FS_LEFT].y = mViewProjMatrix._24 + mViewProjMatrix._21;
		mPlanes[FS_LEFT].z = mViewProjMatrix._34 + mViewProjMatrix._31;
		mPlanes[FS_LEFT].w = mViewProjMatrix._44 + mViewProjMatrix._41;
		XMStoreFloat4(&mPlanes[FS_LEFT], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_LEFT])));

		/// right
		mPlanes[FS_RIGHT].x = mViewProjMatrix._14 - mViewProjMatrix._11;
		mPlanes[FS_RIGHT].y = mViewProjMatrix._24 - mViewProjMatrix._21;
		mPlanes[FS_RIGHT].z = mViewProjMatrix._34 - mViewProjMatrix._31;
		mPlanes[FS_RIGHT].w = mViewProjMatrix._44 - mViewProjMatrix._41;
		XMStoreFloat4(&mPlanes[FS_RIGHT], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_RIGHT])));

		/// top
		mPlanes[FS_TOP].x = mViewProjMatrix._14 - mViewProjMatrix._12;
		mPlanes[FS_TOP].y = mViewProjMatrix._24 - mViewProjMatrix._22;
		mPlanes[FS_TOP].z = mViewProjMatrix._34 - mViewProjMatrix._32;
		mPlanes[FS_TOP].w = mViewProjMatrix._44 - mViewProjMatrix._42;
		XMStoreFloat4(&mPlanes[FS_TOP], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_TOP])));

		/// buttom
		mPlanes[FS_BUTTOM].x = mViewProjMatrix._14 + mViewProjMatrix._12;
		mPlanes[FS_BUTTOM].y = mViewProjMatrix._24 + mViewProjMatrix._22;
		mPlanes[FS_BUTTOM].z = mViewProjMatrix._34 + mViewProjMatrix._32;
		mPlanes[FS_BUTTOM].w = mViewProjMatrix._44 + mViewProjMatrix._42;
		XMStoreFloat4(&mPlanes[FS_BUTTOM], XMPlaneNormalizeEst(XMLoadFloat4(&mPlanes[FS_BUTTOM])));
	}
Beispiel #15
0
//Needs to be called befor all other drawcalls, and ended with "EndDraw()"
void DirectXGraphicEngine::BeginDraw()
{
	if (m_IsDrawing)
	{
		Logger::Log( "Rendering call Begin was called before end was called", "DirectXRenderSystem", LoggerType::MSG_ERROR );
		return;
	}

	//clear the backbuffer, and depthstencil buffer
	float t_Black[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
	m_DeviceContext->ClearRenderTargetView(m_RenderTargetView, t_Black);
	m_DeviceContext->ClearDepthStencilView(m_DepthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0);

	//clear gbuffers
	for (int i = 0; i < 3; i++)
	{
		m_DeviceContext->ClearRenderTargetView(m_GBufferRTV[i], t_Black);
	}

	m_IsDrawing = true;

	UINT t_Strides = sizeof(XMFLOAT4X4);
	UINT t_Offsets = 0;

	m_DeviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	m_DeviceContext->IASetVertexBuffers(1, 1, &m_InstanceBuffer, &t_Strides, &t_Offsets);



	//update viewmatrix
	DirectXMatrixLibrary* t_MatrixLib = (DirectXMatrixLibrary*)t_MatrixLib->GetInstance();

	UINT t_Size = m_View.size();
	for (size_t i = 0; i < t_Size; i++)
	{
		PerFrameCBuffer t_PFB;
		t_PFB.View = *t_MatrixLib->GetMatrix(m_View.at(i).camera.transformMatrixHandle);
		t_PFB.Proj = *t_MatrixLib->GetMatrix(m_View.at(i).camera.projectionMatrixHandle);
		XMMATRIX t_View = XMLoadFloat4x4(&t_PFB.View);
		XMMATRIX t_Proj = XMLoadFloat4x4(&t_PFB.Proj);
		XMMATRIX t_ViewProj = XMMatrixMultiply(t_View, t_Proj);
		XMStoreFloat4x4(&t_PFB.ViewProj, t_ViewProj);
		
		m_DeviceContext->UpdateSubresource(m_PerFrameCBuffer, 0, nullptr, &t_PFB, 0, 0);
	}
	
}
Beispiel #16
0
void RenderableObject::SetWVPConstantBuffer(bool dynamic) {
	HRESULT hr;

	XMMATRIX worldMat = XMLoadFloat4x4(&worldMatrix);
	XMMATRIX viewProjMat = pD3DEngine->GetViewMatrix() * pD3DEngine->GetOrthoMatrix(); //2d test
	//XMMATRIX viewProjMat = pD3DEngine->GetViewMatrix() * pD3DEngine->GetProjectionMatrix();

	if (dynamic) {
	//Lock the constant buffer so it can be written to.
	D3D11_MAPPED_SUBRESOURCE mappedResource;
	#ifdef USING_BOOST_THREADS
	pD3DEngine->LockDeviceContextMutex();
	#endif
	hr = pDeviceContext->Map(pWVPConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
	#ifdef USING_BOOST_THREADS
	pD3DEngine->UnlockDeviceContextMutex();
	#endif
	

	//Get a pointer to the data in the constant buffer.
	WVPConstantBuffer* dataPtr;
	dataPtr = (WVPConstantBuffer*)mappedResource.pData;

	XMStoreFloat4x4(&dataPtr->worldMatrix, XMMatrixTranspose(worldMat));	
	XMStoreFloat4x4(&dataPtr->viewProjMatrix, XMMatrixTranspose(viewProjMat));	

	//Unlock the constant buffer.
	#ifdef USING_BOOST_THREADS
	pD3DEngine->LockDeviceContextMutex();
	#endif
	pDeviceContext->Unmap(pWVPConstantBuffer, 0);
	#ifdef USING_BOOST_THREADS
	pD3DEngine->UnlockDeviceContextMutex();
	#endif
	
	}
	else {
		WVPConstantBuffer cbPerObj;
		XMStoreFloat4x4(&cbPerObj.worldMatrix, XMMatrixTranspose(worldMat));	
		XMStoreFloat4x4(&cbPerObj.viewProjMatrix, XMMatrixTranspose(viewProjMat));	
		#ifdef USING_BOOST_THREADS
		pD3DEngine->LockDeviceContextMutex();
		#endif
		pDeviceContext->UpdateSubresource(pWVPConstantBuffer, 0, NULL, &cbPerObj, 0, 0 );
		#ifdef USING_BOOST_THREADS
		pD3DEngine->UnlockDeviceContextMutex();
		#endif
		
	}
	//Now set the constant buffer in the vertex shader with the updated values.
	#ifdef USING_BOOST_THREADS
	pD3DEngine->LockDeviceContextMutex();
	#endif
	pDeviceContext->VSSetConstantBuffers(0, 1, &pWVPConstantBuffer);
	#ifdef USING_BOOST_THREADS
	pD3DEngine->UnlockDeviceContextMutex();
	#endif
	
}
	void FogDemo::Render(const GameTime& gameTime)
	{
		ID3D11DeviceContext2* direct3DDeviceContext = mGame.GetDirectXContext().Get();
		direct3DDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
		direct3DDeviceContext->IASetInputLayout(mInputLayout.Get());

		UINT stride = sizeof(VertexPositionTextureNormal);
		UINT offset = 0;
		direct3DDeviceContext->IASetVertexBuffers(0, 1, mVertexBuffer.GetAddressOf(), &stride, &offset);
		direct3DDeviceContext->IASetIndexBuffer(mIndexBuffer.Get(), DXGI_FORMAT_R32_UINT, 0);

		direct3DDeviceContext->VSSetShader(mVertexShader.Get(), nullptr, 0);
		direct3DDeviceContext->PSSetShader(mPixelShader.Get(), nullptr, 0);

		XMMATRIX worldMatrix = XMLoadFloat4x4(&mWorldMatrix);
		XMMATRIX wvp = worldMatrix * mCamera->ViewProjectionMatrix();
		XMStoreFloat4x4(&mVertexCBufferPerObjectData.WorldViewProjection, XMMatrixTranspose(wvp));
		XMStoreFloat4x4(&mVertexCBufferPerObjectData.World, XMMatrixTranspose(worldMatrix));

		const XMFLOAT3& cameraPosition = mCamera->Position();
		mVertexCBufferPerFrameData.CameraPosition = XMFLOAT4(cameraPosition.x, cameraPosition.y, cameraPosition.z, 1.0f);
		mPixelCBufferPerFrameData.CameraPosition = mVertexCBufferPerFrameData.CameraPosition;

		direct3DDeviceContext->UpdateSubresource(mVertexCBufferPerFrame.Get(), 0, nullptr, &mVertexCBufferPerFrameData, 0, 0);
		direct3DDeviceContext->UpdateSubresource(mVertexCBufferPerObject.Get(), 0, nullptr, &mVertexCBufferPerObjectData, 0, 0);
		direct3DDeviceContext->UpdateSubresource(mPixelCBufferPerFrame.Get(), 0, nullptr, &mPixelCBufferPerFrameData, 0, 0);
		direct3DDeviceContext->UpdateSubresource(mPixelCBufferPerObject.Get(), 0, nullptr, &mPixelCBufferPerObjectData, 0, 0);

		static ID3D11Buffer* VSConstantBuffers[] = { mVertexCBufferPerFrame.Get(), mVertexCBufferPerObject.Get() };
		direct3DDeviceContext->VSSetConstantBuffers(0, ARRAYSIZE(VSConstantBuffers), VSConstantBuffers);

		static ID3D11Buffer* PSConstantBuffers[] = { mPixelCBufferPerFrame.Get(), mPixelCBufferPerObject.Get() };
		direct3DDeviceContext->PSSetConstantBuffers(0, ARRAYSIZE(PSConstantBuffers), PSConstantBuffers);

		direct3DDeviceContext->PSSetShaderResources(0, 1, mColorTexture.GetAddressOf());
		direct3DDeviceContext->PSSetSamplers(0, 1, mColorSampler.GetAddressOf());

		direct3DDeviceContext->DrawIndexed(mIndexCount, 0, 0);

		mProxyModel->Render(gameTime);

		mRenderStateHelper.SaveAll();

		mSpriteBatch->Begin();

		std::wostringstream helpLabel;

		helpLabel << "Ambient Intensity (+X/-Y): " << mPixelCBufferPerFrameData.AmbientColor.x << "\n";
		helpLabel << L"Specular Intensity (+DPadUp/-DPadDown): " << mPixelCBufferPerObjectData.SpecularColor.x << "\n";
		helpLabel << L"Specular Power (+RightShoulder/-LeftShoulder): " << mPixelCBufferPerObjectData.SpecularPower << "\n";
		helpLabel << L"Directional Light Intensity (+A/-B): " << mPixelCBufferPerFrameData.LightColor.x << "\n";
		helpLabel << L"Rotate Directional Light (Hold Left Trigger + Right Thumb Stick)";

		mSpriteFont->DrawString(mSpriteBatch.get(), helpLabel.str().c_str(), mTextPosition);

		mSpriteBatch->End();

		mRenderStateHelper.RestoreAll();
	}
Beispiel #18
0
void Camera::moveCam()
{
	XMVECTOR tempRight = XMLoadFloat3(&mRight);
	XMVECTOR tempUp = XMLoadFloat3(&mUp);
	XMVECTOR tempPosition = XMLoadFloat3(&mPosition);
	XMVECTOR tempForward = XMLoadFloat3(&mLook);
	



	//set the camera to look at the character
	camTarget = playerPosition;






	XMVECTOR tempTarget = XMLoadFloat3(&camTarget);

	tempTarget = XMVectorSetY(tempTarget,10);


	
	//rotate camera around the character
	camRotationMatrix = XMMatrixRotationRollPitchYaw(-camPitch, camYaw, 0);
	tempPosition = XMVector3TransformNormal(PlayerForward, camRotationMatrix);
	tempPosition = XMVector3Normalize(tempPosition);


	tempPosition = (tempPosition * -50) + tempTarget;
		
	tempPosition = XMVectorSetY(tempPosition, 30.0f);

	tempForward = XMVector3Normalize(tempTarget - tempPosition);	// Get forward vector based on target
	tempForward = XMVectorSetY(tempForward, 0.0f);	// set forwards y component to 0 so it lays only on

	tempForward= XMVector3Normalize(tempForward);

	tempRight = XMVectorSet(XMVectorGetZ(-tempForward), 0.0f, XMVectorGetX(tempForward), 0.0f);

	tempUp = XMVector3Normalize(XMVector3Cross(XMVector3Normalize(tempPosition - tempTarget), tempRight));



	XMStoreFloat3(&mRight, tempRight);
	XMStoreFloat3(&mUp, tempUp);
	XMStoreFloat3(&mPosition, tempPosition);
	XMStoreFloat3(&mLook, tempForward);

	XMMATRIX tempView = XMLoadFloat4x4(&mView);


	tempView = XMMatrixLookAtLH(tempPosition, tempTarget, tempUp);

	XMStoreFloat4x4(&mView, tempView);

	///////////mising some code maybe
}
void CrateApp::DrawScene()
{
	md3dImmediateContext->ClearRenderTargetView(mRenderTargetView,reinterpret_cast<const float*>(&Colors::LightSteelBlue));
	md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);

	md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
	md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

	UINT stride = sizeof(Vertex::Basic32);
	UINT offset = 0;

	XMMATRIX view = XMLoadFloat4x4(&mView);
	XMMATRIX proj  = XMLoadFloat4x4(&mProj);
	XMMATRIX viewProj = view*proj;

	//set cbuffer per frame
	Effects::BasicFX->SetDirLights(mDirLights);
	Effects::BasicFX->SetEyePosW(mEyePosW);

	ID3DX11EffectTechnique *activeTech = Effects::BasicFX->Light2TexTech;
	D3DX11_TECHNIQUE_DESC techDesc;
	activeTech->GetDesc(&techDesc);

	for(UINT p = 0; p < techDesc.Passes; ++p)
	{
		md3dImmediateContext->IASetVertexBuffers(0,1,&mBoxVB,&stride,&offset);
		md3dImmediateContext->IASetIndexBuffer(mBoxIB,DXGI_FORMAT_R32_UINT,0);

		XMMATRIX world = XMLoadFloat4x4(&mBoxWorld);
		XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
		XMMATRIX worldViewProj = world*view*proj;

		XMMATRIX texTransform = XMLoadFloat4x4(&mTexTransform);

		Effects::BasicFX->SetWorld(world);
		Effects::BasicFX->SetWorldInvTranspose(worldInvTranspose);
		Effects::BasicFX->SetWorldViewProj(worldViewProj);
		Effects::BasicFX->SetTexTransform(texTransform);
		Effects::BasicFX->SetMaterial(mBoxMat);
		Effects::BasicFX->SetDiffuseMap(mDiffuseMapSRV);

		activeTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
		md3dImmediateContext->DrawIndexed(mBoxIndexCount, mBoxIndexOffset, mBoxVertexOffset);
	}
	HR(mSwapChain->Present(0, 0));
}
Beispiel #20
0
	void ParticleRenderer::ExtractScreenSpaceUnitVectors(const XMFLOAT4X4& projWorldMatrix) {
		// inverse, so screen->world?
		XMFLOAT4X4 invProj;
		XMStoreFloat4x4(&invProj, XMMatrixTranspose(XMLoadFloat4x4(&projWorldMatrix)));
		XMStoreFloat3(&screenSpaceUnitX, XMVector3Normalize(XMLoadFloat3((XMFLOAT3*)&invProj._11)));
		XMStoreFloat3(&screenSpaceUnitY, XMVector3Normalize(XMLoadFloat3((XMFLOAT3*)&invProj._21)));
		XMStoreFloat3(&screenSpaceUnitZ, XMVector3Normalize(XMLoadFloat3((XMFLOAT3*)&invProj._31)));
	}
XMFLOAT3 EliteEnemyShip::getPosition()
{
	XMFLOAT4 pos;
	XMFLOAT4 orig = XMFLOAT4(0,0,0,1);
	XMFLOAT4X4 mat = *(body->getWorldMatrix());
	XMStoreFloat4(&pos, XMVector4Transform(XMLoadFloat4(&orig), XMLoadFloat4x4(&mat)));
	return (XMFLOAT3(pos.x, pos.y, pos.z));
}
Beispiel #22
0
bool TerrainShaderClass::SetShadowConstantBufferParamters(ID3D11DeviceContext* pDeviceContext, ObjectClass* pObject, CameraClass* pCamera, PointLightClass* pPointLight)
{
	HRESULT result;
	D3D11_MAPPED_SUBRESOURCE mappedResource;
	ShadowBuffer* dataPtr;
	unsigned int bufferNumber;

	// Lock the constant buffer so it can be written to.
	result = pDeviceContext->Map(mShadowBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
	if (FAILED(result))
	{
		return false;
	}

	// Get a pointer to the data in the constant buffer.
	dataPtr = (ShadowBuffer*)mappedResource.pData;
	
	XMMATRIX world = XMLoadFloat4x4(&pObject->GetWorldMatrix());

	XMMATRIX view = XMLoadFloat4x4(&pCamera->GetViewMatrix());
	XMMATRIX proj = XMLoadFloat4x4(&pCamera->GetProjMatrix());

	XMMATRIX lview = XMLoadFloat4x4(&pPointLight->GetViewMatrix());
	XMMATRIX lproj = XMLoadFloat4x4(&pPointLight->GetProjMatrix());

	XMMATRIX lWVP = XMMatrixTranspose(world*lview*lproj);
	XMMATRIX WVP = XMMatrixTranspose(world*view*proj);


	XMStoreFloat4x4(&dataPtr->worldViewProj, WVP);
	XMStoreFloat4x4(&dataPtr->world, world);
	XMStoreFloat4x4(&dataPtr->LightWorldViewProj, lWVP);
	XMFLOAT3 cP = pCamera->GetPosition();
	dataPtr->camPos = XMFLOAT4(cP.x, cP.y, cP.z, 0);

	// Unlock the constant buffer.
	pDeviceContext->Unmap(mShadowBuffer, 0);

	// Set the position of the constant buffer in the vertex shader.
	bufferNumber = 0;

	// Set the constant buffer in the shader with the updated values.
	pDeviceContext->GSSetConstantBuffers(bufferNumber, 1, &mShadowBuffer);

	return true;
}
Beispiel #23
0
// рисовать модель
bool AnimModel::Draw(bool toShadowMap) {

	// установить константы
	myXMFLOAT3 positionJP = position - Mediator::camera->GetPosition();
	XMMATRIX W_JP = XMMatrixTranslation(positionJP.x, positionJP.y, positionJP.z);
	XMMATRIX R = XMLoadFloat4x4(&GetRotationMatrix());
	if (recreateFinalMatrices) {
		if (restCurClip) CreateFinalMatrices(curClip, curFrame[curClip], finalMatrices);
		else CreateFinalMatrices(curFrame, blendFactors, finalMatrices);
		recreateFinalMatrices = false;
	}
	UINT vertexStride = sizeof(VertPos3Nor2Tex2W1Bone2);
	UINT vertexOffset = 0;

	// установить параметры
	Mediator::pDevContext->IASetVertexBuffers(0, 1, &pVertexBuffer, &vertexStride, &vertexOffset);
	Mediator::pDevContext->IASetIndexBuffer(pIndexBuffer, DXGI_FORMAT_R32_UINT, 0);
	Mediator::pDevContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	Mediator::pDevContext->IASetInputLayout(Mediator::pInputLayoutPos3Nor3Tex2W1Bone2);
	if (toShadowMap) {
		Mediator::pDevContext->VSSetShader(Mediator::pVSShadow, NULL, 0);
		Mediator::pDevContext->PSSetShader(Mediator::pPSEmpty, NULL, 0);
	}
	else {
		Mediator::pDevContext->PSSetShaderResources(TEXTURE_BUFFER, 1, &pSRtexture);
		Mediator::pDevContext->VSSetShader(Mediator::pVSPosNorTexWBone, NULL, 0);
		Mediator::pDevContext->PSSetShader(Mediator::pPSPosNorTex, NULL, 0);
	}

	// обновить константный буфер шейдера
	D3D11_MAPPED_SUBRESOURCE mappedData;
	HR(Mediator::pDevContext->Map(Mediator::cbufAnimModel, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedData));
	CbufAnimModel* cbuf = reinterpret_cast<CbufAnimModel*>(mappedData.pData);
	XMStoreFloat4x4(&cbuf->gWorld, XMMatrixTranspose(R * W_JP));
	for (UINT i(0); i < bonesAmount; i++) {
		XMStoreFloat4x4(&cbuf->gBones[i], XMMatrixTranspose(XMLoadFloat4x4(&finalMatrices[i])));
	}
	Mediator::pDevContext->Unmap(Mediator::cbufAnimModel, 0);
	Mediator::pDevContext->VSSetConstantBuffers(SR_ANIMMODEL, 1, &Mediator::cbufAnimModel);

	// рисование
	Mediator::pDevContext->DrawIndexed(indicesAmount, 0, 0);

	return true;

}
Beispiel #24
0
	uint Texture2DShader::Render(ID3D11DeviceContext* pDeviceContext, GraphicSettings* settings, translationData* modelData, XMFLOAT4X4 view, XMFLOAT4X4 projection, XMFLOAT4X4 ortho)
	{
		uint result;
		XMMATRIX mWorld = XMLoadFloat4x4(&modelData->objectTranslation);
		XMMATRIX mOrtho = XMLoadFloat4x4(&ortho);

		XMMATRIX WO = XMMatrixTranspose(mWorld*mOrtho);

		TBuffer data;
		XMStoreFloat4x4(&data.mWO, WO);

		result = mBuffer->SetConstantBuffer(pDeviceContext, &data);
		iferr(result) return result;

		RenderShader(pDeviceContext, modelData->indexCount, modelData->indexStart);

		return 0;
	}
void Assignment5::DrawScene()
{
    XMFLOAT4 backgroundColor;
    XMStoreFloat4(&backgroundColor, Colors::LightSteelBlue);
    md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, 
        reinterpret_cast<float*>(&backgroundColor));
    md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
    drawToDisplay();
    md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);

    XMMATRIX view = XMLoadFloat4x4(&mView);
    XMMATRIX proj = XMLoadFloat4x4(&mProj);
    XMMATRIX viewProj = view*proj;

    m_Box.draw(md3dImmediateContext, viewProj);
    m_Phone.draw(md3dImmediateContext, viewProj);
    HR(mSwapChain->Present(0, 0));
}
Beispiel #26
0
	//! Updates the view matrix.
	void Camera::UpdateViewMatrix()
	{
		// Update the right vector.
		XMVECTOR up = XMLoadFloat3(&mUp);
		XMVECTOR dir = XMLoadFloat3(&GetDirection());
		XMVECTOR right = XMVector3Cross(up, dir);
		right = XMVector3Normalize(right);
		XMStoreFloat3(&mRight, right);

		// Update the view matrix
		XMVECTOR pos = XMLoadFloat3(&mPosition);
		XMVECTOR target = XMLoadFloat3(&mTarget);
		XMStoreFloat4x4(&mView, XMMatrixLookAtLH(pos, target, up));

		XMFLOAT4X4 viewProj;
		XMStoreFloat4x4(&viewProj, XMLoadFloat4x4(&GetViewMatrix()) * XMLoadFloat4x4(&GetProjectionMatrix()));
		mFrustum.BuildFromViewProjection(viewProj);
	}
Beispiel #27
0
float ObjectToCamera(XMFLOAT4X4* _objMatrix, XMFLOAT3 _cameraPos)
{
	XMVECTOR obj = XMVectorZero();
	obj = XMVector3Transform(obj, XMLoadFloat4x4(_objMatrix));
	float ObjtoCameraX = XMVectorGetX(obj) - _cameraPos.x;
	float ObjtoCameraY = XMVectorGetY(obj) - _cameraPos.y;
	float ObjtoCameraZ = XMVectorGetZ(obj) - _cameraPos.z;
	return ObjtoCameraX*ObjtoCameraX + ObjtoCameraY*ObjtoCameraY + ObjtoCameraZ*ObjtoCameraZ;
}
Beispiel #28
0
void Application::Draw()
{
    // Clear the back buffer
    float ClearColor[4] = {0.1f, 0.1f, 0.1f, 1.0f}; // red,green,blue,alpha
    _pImmediateContext->ClearRenderTargetView(_pRenderTargetView, ClearColor);
	_pImmediateContext->ClearDepthStencilView(_depthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);

	XMMATRIX world1 = XMLoadFloat4x4(&_cubbe1.GetWorld());
	XMMATRIX world2 = XMLoadFloat4x4(&_cubbe2.GetWorld());
	XMMATRIX view = XMLoadFloat4x4(&_view);
	XMMATRIX projection = XMLoadFloat4x4(&_projection);

	// Draw cube 1
    ConstantBuffer cb;
	cb.mWorld = XMMatrixTranspose(world1);
	cb.mView = XMMatrixTranspose(view);
	cb.mProjection = XMMatrixTranspose(projection);
	//cb.mEyePosW = _cam.GetPosition();
	cb.mLight = _light;


	_pImmediateContext->UpdateSubresource(_pConstantBuffer, 0, nullptr, &cb, 0, 0);

	//_pImmediateContext->VSSetShader(_pVertexShader, nullptr, 0);
	//_pImmediateContext->VSSetConstantBuffers(0, 1, &_pConstantBuffer);
	//_pImmediateContext->PSSetShader(_pPixelShader, nullptr, 0);
	//_pImmediateContext->DrawIndexed(36, 0, 0);        
	_cubbe1.Draw(_pd3dDevice, _pImmediateContext, _pConstantBuffer, &cb, _pVertexShader, _pPixelShader);
	// Draw cube 2
	cb.mWorld = XMMatrixTranspose(world2);
	cb.mView = XMMatrixTranspose(view);
	cb.mProjection = XMMatrixTranspose(projection);
	cb.mLight = _light;
	//cb.mEyePosW = _cam.GetPosition();

	_pImmediateContext->UpdateSubresource(_pConstantBuffer, 0, nullptr, &cb, 0, 0);
	
	//_pImmediateContext->VSSetShader(_pVertexShader, nullptr, 0);
	//_pImmediateContext->VSSetConstantBuffers(0, 1, &_pConstantBuffer);
	//_pImmediateContext->PSSetShader(_pPixelShader, nullptr, 0);
	//_pImmediateContext->DrawIndexed(36, 0, 0);*/
	_cubbe2.Draw(_pd3dDevice, _pImmediateContext, _pConstantBuffer, &cb, _pVertexShader, _pPixelShader);
    _pSwapChain->Present(0, 0);
}
Beispiel #29
0
void CMinotaurSpawn::SetWorldMatrix(const XMFLOAT4X4 world)
{
	m_mWorld = world;
	for (size_t i = 0; i < meshes.size(); i++)
	{
		XMMATRIX newMatrix;
		XMMATRIX tempPrefabWorld = XMLoadFloat4x4(&m_mWorld);
		XMMATRIX tempObjectWorld = XMLoadFloat4x4(&meshLocalMatricies[i]);
		newMatrix = tempObjectWorld * tempPrefabWorld;
		XMFLOAT4X4 newWorld;
		XMStoreFloat4x4(&newWorld, newMatrix);
		m_vRenderMeshes[i]->GetPositionMatrix() = newWorld;
		FindDoorStartAndEnd(i, XMFLOAT3(newWorld._41, newWorld._42, newWorld._43));



	}



	for (unsigned int collider = 0; collider < m_pvColliders.size(); collider++)
		m_pvColliders[collider]->UpdatePosition(XMFLOAT3(m_mWorld._41, m_mWorld._42, m_mWorld._43));

	for (size_t i = 0; i < m_vObjects.size(); i++)
	{

		XMMATRIX newMatrix;
		XMMATRIX tempPrefabWorld = XMLoadFloat4x4(&m_mWorld);
		XMMATRIX tempObjectWorld = XMLoadFloat4x4(&m_vObjects[i]->GetWorldMatrix());
		newMatrix = tempObjectWorld * tempPrefabWorld;
		XMFLOAT4X4 newWorld;
		XMStoreFloat4x4(&newWorld, newMatrix);


		m_vObjects[i]->SetWorldMatrix(newWorld);


		for (unsigned int collider = 0; collider < m_vObjects[i]->GetColliders().size(); collider++)
			m_vObjects[i]->GetColliders()[collider]->UpdatePosition(XMFLOAT3(world._41, world._42, world._43));

	}


}
void D3DPBRApp::DrawScene(Camera& camera)
{
	md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
	md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	md3dImmediateContext->RSSetViewports(1, &mScreenViewport);

	UINT stride = sizeof(Vertex::Basic32);
	UINT offset = 0;

	//

	XMMATRIX view     = camera.View();
	XMMATRIX proj     = camera.Proj();
	XMMATRIX viewProj = camera.ViewProj();




	// Set per frame constants.
	Effects::CommonPassFX->SetDirLights(mDirLights);
	Effects::CommonPassFX->SetEyePosW(mCam.GetPosition());
	Effects::CommonPassFX->SetEnvMap(mDynamicCubeMapSRV);

	ID3DX11EffectTechnique* activeMeshTech = Effects::CommonPassFX->Light1Tech;

	D3DX11_TECHNIQUE_DESC techDesc;
	activeMeshTech->GetDesc( &techDesc );
	for(UINT p = 0; p < techDesc.Passes; ++p)
	{
		// Draw the Mesh.

		if( GetAsyncKeyState('1') & 0x8000 )
			md3dImmediateContext->RSSetState(RenderStates::WireframeRS);

		md3dImmediateContext->IASetVertexBuffers(0, 1, &m_pVB, &stride, &offset);
		md3dImmediateContext->IASetIndexBuffer(m_pIB, DXGI_FORMAT_R32_UINT, 0);

		XMMATRIX world = XMLoadFloat4x4(&mMeshWorld);
		XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
		XMMATRIX worldViewProj = world*view*proj;

		Effects::CommonPassFX->SetWorld(world);
		Effects::CommonPassFX->SetWorldInvTranspose(worldInvTranspose);
		Effects::CommonPassFX->SetWorldViewProj(worldViewProj);
		Effects::CommonPassFX->SetMaterial(mMeshMat);

		activeMeshTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
		md3dImmediateContext->DrawIndexed(m_indexnum, 0, 0);

		//m_pSky->Draw(md3dImmediateContext, camera);

		// Restore default
		md3dImmediateContext->RSSetState(0);
	}

}