void RayTracingDemo::draw(const GameTimer & timer) { mTextureSize = { static_cast<float>(mGame->screenWidth()), static_cast<float>(mGame->screenHeight()) }; ID3D11DeviceContext * deviceContext = mGame->deviceContext(); mMaterial->TextureSize() << XMLoadFloat2(&mTextureSize); mMaterial->BlueColor() << mBlueColor; mMaterial->CameraPosition() << mCamera->positionVector(); mMaterial->InverseViewMatrix() << XMMatrixInverse(nullptr,mCamera->viewMatrix()); mMaterial->InverseProjectionMatrix() << XMMatrixInverse(nullptr, mCamera->projectionMatrix()); mMaterial->ViewMatrix() << mCamera->viewMatrix(); mMaterial->Position() << XMLoadFloat3(&mPosition); mMaterial->LightPosition() << XMLoadFloat3(&mLightPosition); mMaterial->ProjectionMatrix() << mCamera->projectionMatrix(); //mMaterial->SpherePosition() << mPosition; mMaterial->OutputTexture() << mOutputTexture; mComputePass->apply(0, deviceContext); deviceContext->Dispatch(mThreadGroupCount.x, mThreadGroupCount.y, 1); static ID3D11UnorderedAccessView * emptyUAV = nullptr; deviceContext->CSSetUnorderedAccessViews(0, 1, &emptyUAV, nullptr); mFullScreenQuad->draw(timer); }
DirectX::SimpleMath::Ray D3D11App::CalcPickingRay(int sx, int sy) { XMMATRIX view = g_objTrackballCameraController.View(); //投影变换 Matrix P = g_objTrackballCameraController.Proj(); float vx = (+2.0f*sx / mClientWidth - 1.0f) / (P(0, 0)); float vy = (-2.0f*sy / mClientHeight + 1.0f) / (P(1, 1)); // Ray definition in view space. XMVECTOR rayOrigin = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f); XMVECTOR rayDir = XMVectorSet(vx, vy, 1.0f, 0.0f); XMMATRIX invP = XMMatrixInverse(&XMMatrixDeterminant(P), P); // Tranform ray to local space of Mesh. XMMATRIX V = view; XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(V), V); XMMATRIX W = Matrix::Identity; XMMATRIX invWorld = XMMatrixInverse(&XMMatrixDeterminant(W), W); XMMATRIX toLocal = XMMatrixMultiply(invView, invWorld); rayOrigin = XMVector3TransformCoord(rayOrigin, toLocal); rayDir = XMVector3TransformNormal(rayDir, toLocal); // Make the ray direction unit length for the intersection tests. rayDir = XMVector3Normalize(rayDir); DirectX::SimpleMath::Ray ray(rayOrigin, rayDir); return ray; }
ASCVector2 ASCDX9Renderer::GetWorldPosition(FLOAT32 fX, FLOAT32 fY) { #define CustomPickingThing ASCVector2 vReturn; vReturn.Set( fX, fY ); #ifdef CustomPickingThing vReturn.Set( fX - ((SC_FLOAT(Ascension::Width())+7.5f) * 0.5f), fY - (SC_FLOAT(Ascension::Height()) * 0.5f) ); //vReturn.Set((vReturn.X() / 38.0f) - 0.079f, (vReturn.Y() / 38.5f) - 0.143f); vReturn.Set((vReturn.X() / 38.6f) - 0.0f, (vReturn.Y() / 38.8f) - 0.0f); #else XMMATRIX matView = *reinterpret_cast<XMMATRIX*>(&m_ViewMatrix); XMMATRIX matProj = *reinterpret_cast<XMMATRIX*>(&m_ProjectionMatrix); XMVECTOR vecSource; XMVECTOR vecTransformed; matProj = XMMatrixInverse(&vecSource, matProj); matView = XMMatrixInverse(&vecSource, matView); XMMATRIX matTransform = matView;//XMMatrixMultiply( matView, matProj ); vecSource.m128_f32[0] = fX; vecSource.m128_f32[1] = fY; vecSource.m128_f32[2] = 0.0f; vecSource.m128_f32[3] = 0.0f; vecTransformed = XMVector2Transform(vecSource, matTransform); vReturn.Set( vecTransformed.m128_f32[0], vecTransformed.m128_f32[1] ); #endif return vReturn; }
void Direct3DObject::Draw (ID3D11DeviceContext* deviceContext, Direct3DCamera* cam) { BEGIN_EXCEPTION_HANDLING EnterCriticalSection (); //printf ("%d\n", vertices_.size()); uint16_t i = rand () % vertices_.size (); //printf ("%f %f %f\n", vertices_[i].x, vertices_[i].y, vertices_[i].z); if (buffersSet_ == false) _EXC_N (BUFFERS_NOT_SET, "D3D: Unable to draw with the buffers not set (obj %d)" _ objectId_) if (vertices_.size () == 0) _EXC_N (EMPTY_VERTICES, "D3D: Unable to draw object with empty vertex buffer (obj %d)" _ objectId_) UINT stride = sizeof (Vertex_t); UINT offset = 0; deviceContext->IASetVertexBuffers (0, 1, &vertexBuffer_, &stride, &offset); if (drawIndexed_) { if (indices_.size () == 0) _EXC_N (EMPTY_INDICES, "D3D: Unable to draw object with empty index buffer (obj %d)" _ objectId_) deviceContext->IASetIndexBuffer (indexBuffer_, DXGI_FORMAT_R32_UINT, 0); } XMVECTOR temp; currM_.objData_.World = XMMatrixTranspose (currM_.world_); currM_.objData_.View = XMMatrixTranspose (cam->GetView()); currM_.objData_.Projection = XMMatrixTranspose (cam->GetProjection()); currM_.objData_.InverseView = XMMatrixTranspose (XMMatrixInverse (&temp, cam->GetView ())); currM_.objData_.InverseProjection = XMMatrixTranspose (XMMatrixInverse(&temp, cam->GetProjection ())); cbManager_->Update (objectBufferN_, deviceContext); cbManager_->SendVSBuffer (objectBufferN_, deviceContext); cbManager_->SendGSBuffer (objectBufferN_, deviceContext); cbManager_->SendPSBuffer (objectBufferN_, deviceContext); deviceContext->IASetPrimitiveTopology (topology_); if (drawIndexed_) deviceContext->DrawIndexed (static_cast<UINT> (indices_.size ()), 0, 0); else deviceContext->Draw (static_cast<UINT> (vertices_.size ()), 0); ExitCriticalSection (); END_EXCEPTION_HANDLING (DRAW_OBJECT) }
void Direct3D::updateConstantBuffers() { //First pass constant buffer update m_FirstPassStruct.firstPass = 1; m_DeviceContext->UpdateSubresource(m_FirstPassCBuffer, 0, 0, &m_FirstPassStruct, 0, 0); m_DeviceContext->CSSetConstantBuffers(0, 1, &m_FirstPassCBuffer); //Primary Constant buffer PrimaryConstBuffer PCBufferStruct; PCBufferStruct.cameraPos = m_pCamera->getPosition(); //Inverse view matrix XMMATRIX mInvView = XMLoadFloat4x4(&m_pCamera->getViewMat()); XMVECTOR mViewDet = XMMatrixDeterminant(mInvView); mInvView = XMMatrixInverse(&mViewDet, mInvView); mInvView = XMMatrixTranspose(mInvView); XMStoreFloat4x4(&PCBufferStruct.IV, mInvView); //Inverse projection matrix XMMATRIX mInvProj = XMLoadFloat4x4(&m_pCamera->getProjMat()); XMVECTOR mProjDet = XMMatrixDeterminant(mInvProj); mInvProj = XMMatrixInverse(&mProjDet, mInvProj); mInvProj = XMMatrixTranspose(mInvProj); XMStoreFloat4x4(&PCBufferStruct.IP, mInvProj); m_DeviceContext->UpdateSubresource(m_PrimaryCBuffer, 0, 0, &PCBufferStruct, 0, 0); //Intersection constant buffer IntersectionConstBuffer ICBufferStruct; ICBufferStruct.sphere = m_sphere; for(int i = 0; i < NROFTRIANGLES; i++) { ICBufferStruct.triangles[i] = m_triangles[i]; } ICBufferStruct.nrOfFaces = m_mesh.getFaces(); ICBufferStruct.pad = XMFLOAT3(0.f, 0.f, 0.f); m_DeviceContext->UpdateSubresource(m_IntersectionCBuffer, 0, 0, &ICBufferStruct, 0, 0); //Color constant buffer ColorConstBuffer CCBufferStruct; CCBufferStruct.sphere = m_sphere; for(int i = 0; i < NROFTRIANGLES; i++) { CCBufferStruct.triangles[i] = m_triangles[i]; } for(int i = 0; i < NROFLIGHTS; i++) { CCBufferStruct.lightList[i] = m_lightList[i]; } CCBufferStruct.nrOfFaces = m_mesh.getFaces(); CCBufferStruct.pad = XMFLOAT3(0.f, 0.f, 0.f); m_DeviceContext->UpdateSubresource(m_ColorCBuffer, 0, 0, &CCBufferStruct, 0, 0); }
bool ObjectModel::Run( ID3D11Device* dev, ID3D11DeviceContext* devCon) { HRESULT tester = 0; #pragma region place on map ProjView->view = XMMatrixInverse(nullptr, ProjView->view); D3D11_MAPPED_SUBRESOURCE mapRes; ZeroMemory(&mapRes, sizeof(D3D11_MAPPED_SUBRESOURCE)); tester = devCon->Map(matrixLocationBuffer[0], NULL, D3D11_MAP_WRITE_DISCARD, NULL, &mapRes); memcpy(mapRes.pData, &world, sizeof(XMMATRIX)); devCon->Unmap(matrixLocationBuffer[0], NULL); ZeroMemory(&mapRes, sizeof(D3D11_MAPPED_SUBRESOURCE)); tester = devCon->Map(matrixLocationBuffer[1], NULL, D3D11_MAP_WRITE_DISCARD, NULL, &mapRes); memcpy(mapRes.pData, ProjView, sizeof(ProjViewMatricies)); devCon->Unmap(matrixLocationBuffer[1], NULL); ProjView->view = XMMatrixInverse(nullptr, ProjView->view); devCon->VSSetConstantBuffers(0, 2, matrixLocationBuffer); #pragma endregion #pragma region VS and PS UINT strides; UINT offsets; strides = sizeof(Simple_Vert); offsets = 0; devCon->IASetVertexBuffers(0, 1, &VertBuff, &strides, &offsets); devCon->IASetIndexBuffer(IndexBuff, DXGI_FORMAT_R32_UINT, offsets); // TODO: PART 2 STEP 9b devCon->VSSetShader(vertexShader, 0, 0); devCon->PSSetShader(pixelShader, 0, 0); // TODO: PART 2 STEP 9c devCon->IASetInputLayout(layout); // TODO: PART 2 STEP 9d //devCon->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); // TODO: PART 2 STEP 10 devCon->DrawIndexed(vertexIndices.size(), 0, 0); #pragma endregion return true; }
vector KinectMeshAnimator::GetBindDirection(int index1, int index2) { Joint* joint1 = bindings[index1]; Joint* joint2 = bindings[index2]; if (!joint1 || !joint2) return XMVectorSet(0.0, 1.0, 0.0, 0.0); matrix4x4 pose1 = XMMatrixInverse(0, XMLoadFloat4x4(&joint1->inverseBindPose)); matrix4x4 pose2 = XMMatrixInverse(0, XMLoadFloat4x4(&joint2->inverseBindPose)); vector dir = pose2.r[3] - pose1.r[3]; return XMVector3Normalize(dir); }
bool ObjectModel::FloorRun( ID3D11Device* dev, ID3D11DeviceContext* devCon) { HRESULT tester = 0; #pragma region place on map ProjView->world = world;// *XMMatrixRotationX(180); ProjView->view = XMMatrixInverse(nullptr, ProjView->view); D3D11_MAPPED_SUBRESOURCE mapRes; ZeroMemory(&mapRes, sizeof(D3D11_MAPPED_SUBRESOURCE)); tester = devCon->Map(matrixLocationBuffer[1], NULL, D3D11_MAP_WRITE_DISCARD, NULL, &mapRes); memcpy(mapRes.pData, ProjView, sizeof(ProjViewMatricies)); devCon->Unmap(matrixLocationBuffer[1], NULL); devCon->VSSetConstantBuffers(0, 1, &matrixLocationBuffer[1]); ProjView->view = XMMatrixInverse(nullptr, ProjView->view); ProjView->world = XMMatrixIdentity(); #pragma endregion ID3D11ShaderResourceView *nullshader = NULL; #pragma region VS and PS UINT strides; UINT offsets; strides = sizeof(StrideStruct); offsets = 0; devCon->IASetVertexBuffers(0, 1, &VertBuff, &strides, &offsets); devCon->IASetIndexBuffer(IndexBuff, DXGI_FORMAT_R32_UINT, offsets); devCon->PSSetShaderResources(0, 1, &ObjTexture[0]); devCon->VSSetShader(vertexShader, 0, 0); devCon->PSSetShader(pixelShader, 0, 0); devCon->IASetInputLayout(layout); devCon->OMSetBlendState(0, 0, 0xffffffff); devCon->DrawIndexed(vertexIndices.size(), 0, 0); devCon->PSSetShaderResources(0, 1, &nullshader); #pragma endregion return true; }
int DuckHuntMain::pick(float x, float y, std::vector<BasicModelInstance> models) { XMMATRIX P = mCam.Proj(); // Compute picking ray in view space. int newWidth, newHeight; float fs; newWidth = mScreenViewport.Width; newHeight = mScreenViewport.Height; fs = 1.0f; float vx = (+2.0f*x / newWidth - fs) / P(0, 0); float vy = (-2.0f*y / newHeight + fs) / P(1, 1); // Ray definition in view space. XMVECTOR rayOrigin = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f); XMVECTOR rayDir = XMVectorSet(vx, vy, 1.0f, 0.0f); // Tranform ray to local space of Mesh. XMMATRIX V = mCam.View(); XMMATRIX invView = XMMatrixInverse(&XMMatrixDeterminant(V), V); for (unsigned i = 0; i < models.size(); ++i) { XMMATRIX W = XMLoadFloat4x4(&models[i].World); XMMATRIX invWorld = XMMatrixInverse(&XMMatrixDeterminant(W), W); XMMATRIX toLocal = XMMatrixMultiply(invView, invWorld); rayOrigin = XMVector3TransformCoord(rayOrigin, toLocal); rayDir = XMVector3TransformNormal(rayDir, toLocal); // Make the ray direction unit length for the intersection tests. rayDir = XMVector3Normalize(rayDir); float tmin = 0.0f; // The Returned Distance if (XNA::IntersectRayAxisAlignedBox(rayOrigin, rayDir, &models[i].Model->collisionBox, &tmin)) { //WE ARE IN THE MESH .. DO WHATEVER YOU WANT return i; } } return -1; }
void camera::update() { m_rotationX = XMMatrixRotationX(m_rotateDeltaY); m_rotationY = XMMatrixRotationY(m_rotateDeltaX); m_rotateMatrix = m_rotationX*m_rotationY; dir = XMFLOAT3(m_rotateMatrix.r->m128_f32[8], m_rotateMatrix.r->m128_f32[9], m_rotateMatrix.r->m128_f32[10]); originPos.x += dir.x*m_deltaZ; originPos.y += dir.y*m_deltaZ; originPos.z += dir.z*m_deltaZ; dir = XMFLOAT3(m_rotateMatrix.r->m128_f32[4], m_rotateMatrix.r->m128_f32[5], m_rotateMatrix.r->m128_f32[6]); originPos.x += dir.x*m_deltaY; originPos.y += dir.y*m_deltaY; originPos.z += dir.z*m_deltaY; dir = XMFLOAT3(m_rotateMatrix.r->m128_f32[0], m_rotateMatrix.r->m128_f32[1], m_rotateMatrix.r->m128_f32[2]); originPos.x += dir.x*m_deltaX; originPos.y += dir.y*m_deltaX; originPos.z += dir.z*m_deltaX; /*eyePos[0].x += dir.x*2; eyePos[1].x -= dir.x*2;*/ m_translation = XMMatrixTranslation(originPos.x, originPos.y, originPos.z); m_MultiplyMatrix = m_rotateMatrix*m_translation; //calculate mirror right float Xadjust = 5.0f; float Zadjust = 5.0f; m_translation = XMMatrixTranslation(originPos.x - Xadjust, originPos.y + 0.8f, originPos.z - Zadjust); m_mirrorRightViewMatrix = (m_rotateYAxisBack*m_rotateMatrix)*m_translation; m_mirrorRightViewMatrix = XMMatrixInverse(NULL, m_mirrorRightViewMatrix); //calculate mirror left m_translation = XMMatrixTranslation(originPos.x + Xadjust, originPos.y + 0.8f, originPos.z - Zadjust); m_mirrorLeftViewMatrix = (m_rotateYAxisBack*m_rotateMatrix)*m_translation; m_mirrorLeftViewMatrix = XMMatrixInverse(NULL, m_mirrorLeftViewMatrix); //calculate god camera pos m_liftYAxisGod = XMMatrixTranslation(originPos.x, 10.0, originPos.z); m_godCamera = m_rotateXAxisGod*m_liftYAxisGod; //m_godCamera.r->m128_f32[12] = originPos.x; //m_godCamera.r->m128_f32[13] = 0; //m_godCamera.r->m128_f32[14] = originPos.z; m_godCamera = XMMatrixInverse(NULL, m_godCamera); m_viewMatrix = XMMatrixInverse(NULL,m_MultiplyMatrix); }
void MyApp::drawImplicitObjects() { // store current Input Layout & Primitive Topology ID3D11InputLayout* ia; D3D11_PRIMITIVE_TOPOLOGY primTopology; _dxImmedDC->IAGetInputLayout(&ia); _dxImmedDC->IAGetPrimitiveTopology(&primTopology); // no vertex buffer needs a null input layout _dxImmedDC->IASetInputLayout(0); _dxImmedDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); // Variables XMMATRIX mWorld = XMMatrixIdentity(); setMatrixVar(m_fxImplicit, (void*)&mWorld, "World"); setMatrixVar(m_fxImplicit, (void*)&m_camera.getViewMatrix(), "View"); setMatrixVar(m_fxImplicit, (void*)&m_camera.getProjectionMatrix(), "Projection"); setFloatVar(m_fxImplicit, 0, "Time"); setVectorVar(m_fxImplicit, (void*)&m_camera.getPosVector(), "eyePos"); XMVECTOR det; XMMATRIX viewInverse = XMMatrixInverse(&det, m_camera.getViewMatrix()); setMatrixVar(m_fxImplicit, (void*)&viewInverse, "mInverseView"); // draw 4 vertices ID3DX11EffectTechnique * tech = 0; tech = m_fxImplicit->GetTechniqueByIndex(0); tech->GetPassByIndex(0)->Apply(0, _dxImmedDC); _dxImmedDC->Draw( 4, 0 ); // restore Input Layout & Primitive Topology _dxImmedDC->IASetInputLayout(ia); _dxImmedDC->IASetPrimitiveTopology(primTopology); }
void c_app_scene::on_frame_render(ID3D11Device *d3d11_device, ID3D11DeviceContext *d3d11_device_context, double time, float elapsed_time) { XMMATRIX mat_world; XMMATRIX mat_view; XMMATRIX mat_proj; XMMATRIX mat_inv_proj; XMMATRIX mat_wvp; mat_world = convert_d3dxmat_to_xnamat(*m_camera->GetWorldMatrix()); mat_proj = convert_d3dxmat_to_xnamat(*m_camera->GetProjMatrix()); mat_view = convert_d3dxmat_to_xnamat(*m_camera->GetViewMatrix()); mat_wvp = mat_world * mat_view * mat_proj; XMVECTOR det_vec; mat_inv_proj = XMMatrixInverse(&det_vec, mat_proj); ////////////////////////////////////////////////////////////////////////// // Set input layout d3d11_device_context->IASetInputLayout(m_mesh_input_layout); ////////////////////////////////////////////////////////////////////////// // Update constant buffer cb0 cb; cb.mat_wvp = XMMatrixTranspose(mat_wvp); d3d11_device_context->UpdateSubresource(m_cb0, 0, NULL, &cb, 0, 0); m_cb0_var->SetConstantBuffer(m_cb0); ////////////////////////////////////////////////////////////////////////// // Render mesh m_render_scene_tech->GetPassByIndex(0)->Apply(0, d3d11_device_context); m_city_mesh->Render(d3d11_device_context, 0); m_column_mesh->Render(d3d11_device_context, 0); }
void mouseMovement(POINT mouseInfoNew, XMMATRIX* ViewMatrix){ LONG x = mouseInfoNew.x; LONG y = mouseInfoNew.y; float xMovement = (float)960 - x; float yMovement = (float)540 - y; //--------------------------------------- *ViewMatrix = XMMatrixTranspose(*ViewMatrix); XMMATRIX ViewInverse = XMMatrixInverse(NULL, *ViewMatrix); XMFLOAT4X4 View4x4; XMStoreFloat4x4(&View4x4, ViewInverse); XMVECTOR CamPos = XMVectorSet(View4x4._41, View4x4._42, View4x4._43, 0); XMMATRIX RotationX = XMMatrixRotationAxis(XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f), cameraSpeed*xMovement); XMVECTOR newCamLook = (XMVectorSet(View4x4._31, View4x4._32 + cameraSpeed*yMovement, View4x4._33, 0)) + CamPos; *ViewMatrix = XMMatrixLookAtLH(CamPos, newCamLook, { 0, 1, 0 }); *ViewMatrix = *ViewMatrix * RotationX; *ViewMatrix = XMMatrixTranspose(*ViewMatrix); }
void D3DPicking::PickRayVector(float mouseX, float mouseY, const XMMATRIX &camView, const XMMATRIX &camProj) { XMVECTOR pickRayInViewSpaceDir = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f); XMVECTOR pickRayInViewSpacePos = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f); float PRVecX, PRVecY, PRVecZ; //Transform 2D pick position on screen space to 3D ray in View space PRVecX = ((( 2.0f * mouseX) / m_ClientWidth ) - 1 ) / camProj(0,0); PRVecY = -((( 2.0f * mouseY) / m_ClientHeight) - 1 ) / camProj(1,1); PRVecZ = 1.0f; //View space's Z direction ranges from 0 to 1, so we set 1 since the ray goes "into" the screen pickRayInViewSpaceDir = XMVectorSet(PRVecX, PRVecY, PRVecZ, 0.0f); //Uncomment this line if you want to use the center of the screen (client area) //to be the point that creates the picking ray (eg. first person shooter) //pickRayInViewSpaceDir = XMVectorSet(0.0f, 0.0f, 1.0f, 0.0f); // Transform 3D Ray from View space to 3D ray in World space XMMATRIX pickRayToWorldSpaceMatrix; XMVECTOR matInvDeter; //We don't use this, but the xna matrix inverse function requires the first parameter to not be null pickRayToWorldSpaceMatrix = XMMatrixInverse(&matInvDeter, camView); //Inverse of View Space matrix is World space matrix m_pickRayPos = XMVector3TransformCoord(pickRayInViewSpacePos, pickRayToWorldSpaceMatrix); m_pickRayDir = XMVector3TransformNormal(pickRayInViewSpaceDir, pickRayToWorldSpaceMatrix); }
XMMATRIX InverseTranspose(CXMMATRIX M) { XMMATRIX A = M; A.r[3] = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f); XMVECTOR det = XMMatrixDeterminant(A); return XMMatrixTranspose(XMMatrixInverse(&det, A)); }
/** * Invert the matrix. * * @return false if there is no inverse. */ bool CFMat4x4::Inverse( void ) { //Create a vector to store the determinant. XMVECTOR vDeterminant; //Create a copy of the matrix so we can revert if the operation fails. CFMat4x4 matCopy = *this; XMMATRIX& matA = *reinterpret_cast<XMMATRIX*>( this ); XMMATRIX& matTest = *reinterpret_cast<XMMATRIX*>( &matCopy ); //Get the inverse. matTest = XMMatrixInverse( &vDeterminant, matA ); bool bSuccess = false; //Test if the operation was successful. Change the value of bSuccess depending on outcome. XMMatrixIsInfinite( matTest ) ? bSuccess = false : bSuccess = true; //If the operation was successful, copy the inverse into matA. bSuccess ? matA = matTest : matA; //Return success. return bSuccess; }
_Use_decl_annotations_ void XM_CALLCONV Camera::SetCameraView(_In_ XMMATRIX mView) { //m_mView = mView; XMMATRIX mInvView = XMMatrixInverse(nullptr, mView); SetWorld(mInvView); }
void ComputeFrustum(const XMMATRIX& viewProj, Frustum& frustum) { XMVECTOR det; XMMATRIX invViewProj = XMMatrixInverse(&det, viewProj); // Corners in homogeneous clip space XMVECTOR corners[8] = { // 7--------6 XMVectorSet(1.0f, -1.0f, 0.0f, 1.0f), // /| /| XMVectorSet(-1.0f, -1.0f, 0.0f, 1.0f), // Y ^ / | / | XMVectorSet(1.0f, 1.0f, 0.0f, 1.0f), // | _ 3--------2 | XMVectorSet(-1.0f, 1.0f, 0.0f, 1.0f), // | /' Z | | | | XMVectorSet(1.0f, -1.0f, 1.0f, 1.0f), // |/ | 5-----|--4 XMVectorSet(-1.0f, -1.0f, 1.0f, 1.0f), // + ---> X | / | / XMVectorSet(1.0f, 1.0f, 1.0f, 1.0f), // |/ |/ XMVectorSet(-1.0f, 1.0f, 1.0f, 1.0f), // 1--------0 }; // Convert to world space for (uint32 i = 0; i < 8; ++i) corners[i] = XMVector3TransformCoord(corners[i], invViewProj); // Calculate the 6 planes frustum.Planes[0] = XMPlaneFromPoints(corners[0], corners[4], corners[2]); frustum.Planes[1] = XMPlaneFromPoints(corners[1], corners[3], corners[5]); frustum.Planes[2] = XMPlaneFromPoints(corners[3], corners[2], corners[7]); frustum.Planes[3] = XMPlaneFromPoints(corners[1], corners[5], corners[0]); frustum.Planes[4] = XMPlaneFromPoints(corners[5], corners[7], corners[4]); frustum.Planes[5] = XMPlaneFromPoints(corners[1], corners[0], corners[3]); }
void MyApp::drawImplicitToTexture() { // store current Input Layout & Primitive Topology ID3D11InputLayout* ia; D3D11_PRIMITIVE_TOPOLOGY primTopology; _dxImmedDC->IAGetInputLayout(&ia); _dxImmedDC->IAGetPrimitiveTopology(&primTopology); ID3D11RenderTargetView* rtv; ID3D11DepthStencilView* dsv; _dxImmedDC->OMGetRenderTargets(1, &rtv, &dsv); D3D11_VIEWPORT vp; unsigned int num_vp = 1; _dxImmedDC->RSGetViewports(&num_vp, &vp); // no vertex buffer needs a null input layout _dxImmedDC->IASetInputLayout(0); _dxImmedDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); // Set Texture Array as Render Target float clearColor[4] = { 0.6f, 0.7f, 0.5f, 1.0f }; _dxImmedDC->ClearRenderTargetView(m_rtvImplicit, clearColor); _dxImmedDC->OMSetRenderTargets(1, &m_rtvImplicit, 0); D3D11_VIEWPORT new_vp; new_vp.Height = new_vp.Width = (float)m_implicitQuadDimension; new_vp.MaxDepth = 1.0f; new_vp.MinDepth = 0.0f; new_vp.TopLeftX = 0.0f; new_vp.TopLeftY = 0.0f; _dxImmedDC->RSSetViewports(1, &new_vp); // Variables XMMATRIX mWorld = XMMatrixIdentity(); setMatrixVar(m_fxImplicit, (void*)&mWorld, "World"); setMatrixVar(m_fxImplicit, (void*)&m_camera.getViewMatrix(), "View"); setMatrixVar(m_fxImplicit, (void*)&m_camera.getProjectionMatrix(), "Projection"); setFloatVar(m_fxImplicit, 0, "Time"); setVectorVar(m_fxImplicit, (void*)&m_camera.getPosVector(), "eyePos"); setIntVar(m_fxImplicit, glb_iImplicitDepth, "iDepth"); XMVECTOR det; XMMATRIX viewInverse = XMMatrixInverse(&det, m_camera.getViewMatrix()); setMatrixVar(m_fxImplicit, (void*)&viewInverse, "mInverseView"); // draw 4 vertices ID3DX11EffectTechnique * tech = 0; tech = m_fxImplicit->GetTechniqueByIndex(0); for (int i=0; i<5; i++) { setIntVar(m_fxImplicit, i, "iArrayIndex"); tech->GetPassByIndex(0)->Apply(0, _dxImmedDC); _dxImmedDC->Draw( 4, 0 ); } // restore Input Layout & Primitive Topology _dxImmedDC->RSSetViewports(num_vp, &vp); _dxImmedDC->IASetInputLayout(ia); _dxImmedDC->IASetPrimitiveTopology(primTopology); _dxImmedDC->OMSetRenderTargets(1, &rtv, dsv); }
void Engine::PerspCamera::position(void) const { *_frusSpherePosition = *_vforward * _frusSphereDistance; *_viewMatrix = XMMatrixLookAtRH(*_pcamera, *_pcamera + * _vforward, *_vup); *_VPMatrix = *_viewMatrix * *_projectionMatrix; *_IVPMatrix = XMMatrixInverse(NULL, *_VPMatrix); }
void invert(float* determinant = nullptr) { XMVECTOR det; *this = XMMatrixInverse(&det, *this); if (determinant) { *determinant = XMVectorGetX(det); } }
void HydraRenderer::Render(D3DRenderer* renderer) { CBPerObject perObject; perObject.Material.HasDiffuseTex = false; perObject.Material.HasNormalTex = false; perObject.Material.HasSpecTex = false; perObject.Material.HasEmissiveTex = false; HydraManager* hydra = InputSystem::get()->getHydra(); for (int controller = 0; controller < sixenseGetMaxControllers(); controller++) { if (sixenseIsControllerEnabled(controller)) { XMVECTOR rotationQuat = hydra->getRotation(controller); XMVECTOR position = hydra->getPosition(controller); //XMVectorSetZ(position, -XMVectorGetZ(position));//Flip Z axis //position += XMVectorSet(0.0f, 0.9f, 0.0f, 0.0f);//Offset for table height perObject.World = XMMatrixRotationQuaternion(XMQuaternionRotationAxis(XMLoadFloat3(&XMFLOAT3(1.0f, 0.0f, 0.0f)), XMConvertToRadians(90.0f))) * XMMatrixTranslation(0.0f, 0.0f, 0.07f) * //XMMatrixTranslation(0.0f, 0.0f, 0.25f) * XMMatrixRotationQuaternion(rotationQuat) * XMMatrixTranslationFromVector(position); perObject.WorldInvTranspose = XMMatrixInverse(NULL, XMMatrixTranspose(perObject.World)); perObject.WorldViewProj = perObject.World * renderer->getPerFrameBuffer()->ViewProj; renderer->setPerObjectBuffer(perObject); mpPointerRenderer->Render(renderer); //Render root trackers perObject.World = XMMatrixRotationQuaternion(XMQuaternionRotationAxis(XMLoadFloat3(&XMFLOAT3(1.0f, 0.0f, 0.0f)), XMConvertToRadians(90.0f))) * XMMatrixRotationQuaternion(rotationQuat) * XMMatrixTranslationFromVector(position); perObject.WorldInvTranspose = XMMatrixInverse(NULL, XMMatrixTranspose(perObject.World)); perObject.WorldViewProj = perObject.World * renderer->getPerFrameBuffer()->ViewProj; renderer->setPerObjectBuffer(perObject); mpRootRenderer->Render(renderer); } } }
Box::Box(float x, float y, float z, XMVECTOR position, float mass, bool fixed, XMVECTOR orientation) { this->position = position; // its the center position of the box this->velocity = XMVectorSet(0.f, 0.f, 0.f, 0.f); length = XMVectorSet(x, y, z, 0.f); centerOfMass = Point(position, false); this->transform = XMMatrixTranslationFromVector(this->position); this->centerOfMass.fixed = fixed; this->orientation = XMQuaternionRotationRollPitchYawFromVector(orientation); if (fixed) { centerOfMass.mass = 1.0f; massInverse = 0.0f; intertiaTensorInverse = XMMATRIX(); } else { centerOfMass.mass = mass; massInverse = 1.0f / mass; float prefix = (1.0f / 12.0f) * centerOfMass.mass; XMMATRIX matrix = XMMATRIX(XMVectorSet(prefix*(y*y + z*z), 0.f, 0.f, 0.f), XMVectorSet(0.f, prefix * (x*x + z*z), 0.f, 0.f), XMVectorSet(0.f, 0.f, prefix*(x*x + y*y),0.f), XMVectorSet(0.f, 0.f, 0.f, 1.f)); intertiaTensorInverse = XMMatrixInverse(&XMMatrixDeterminant(matrix), matrix); } XMVECTOR xLength = XMVectorSet(x, 0.f, 0.f, 0.f) / 2; XMVECTOR yLength = XMVectorSet(0.f, y, 0.f, 0.f) / 2; XMVECTOR zLength = XMVectorSet(0.f, 0.f, z, 0.f) / 2; for (int i = 0; i < 8; i++) { corners[0] = XMVECTOR(); } this->angularMomentum = XMVECTOR(); this->angularVelocity = XMVECTOR(); this->torqueAccumulator = XMVECTOR(); corners[0] = -xLength - yLength - zLength; corners[1] = xLength - yLength - zLength; corners[2] = -xLength + yLength - zLength; corners[3] = xLength + yLength - zLength; corners[4] = -xLength - yLength + zLength; corners[5] = xLength - yLength + zLength; corners[6] = -xLength + yLength + zLength; corners[7] = xLength + yLength + zLength; }
// Set the render state before drawing this object //----------------------------------------------------------------------------- void CPUTModelDX11::UpdateShaderConstants(CPUTRenderParameters &renderParams) { ID3D11DeviceContext *pContext = ((CPUTRenderParametersDX*)&renderParams)->mpContext; D3D11_MAPPED_SUBRESOURCE mapInfo; pContext->Map( mpModelConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapInfo ); { CPUTModelConstantBuffer *pCb = (CPUTModelConstantBuffer*)mapInfo.pData; // TODO: remove construction of XMM type XMMATRIX world((float*)GetWorldMatrix()); pCb->World = world; CPUTCamera *pCamera = renderParams.mpCamera; XMVECTOR cameraPos = XMLoadFloat3(&XMFLOAT3( 0.0f, 0.0f, 0.0f )); if( pCamera ) { XMMATRIX view((float*)pCamera->GetViewMatrix()); XMMATRIX projection((float*)pCamera->GetProjectionMatrix()); float *pCameraPos = (float*)&pCamera->GetPosition(); cameraPos = XMLoadFloat3(&XMFLOAT3( pCameraPos[0], pCameraPos[1], pCameraPos[2] )); // Note: We compute viewProjection to a local to avoid reading from write-combined memory. // The constant buffer uses write-combined memory. We read this matrix when computing WorldViewProjection. // It is very slow to read it directly from the constant buffer. XMMATRIX viewProjection = view * projection; pCb->ViewProjection = viewProjection; pCb->WorldViewProjection = world * viewProjection; XMVECTOR determinant = XMMatrixDeterminant(world); pCb->InverseWorld = XMMatrixInverse(&determinant, XMMatrixTranspose(world)); } // TODO: Have the lights set their render states? XMVECTOR lightDirection = XMLoadFloat3(&XMFLOAT3( gLightDir.x, gLightDir.y, gLightDir.z )); pCb->LightDirection = XMVector3Normalize(lightDirection); pCb->EyePosition = cameraPos; float *bbCWS = (float*)&mBoundingBoxCenterWorldSpace; float *bbHWS = (float*)&mBoundingBoxHalfWorldSpace; float *bbCOS = (float*)&mBoundingBoxCenterObjectSpace; float *bbHOS = (float*)&mBoundingBoxHalfObjectSpace; pCb->BoundingBoxCenterWorldSpace = XMLoadFloat3(&XMFLOAT3( bbCWS[0], bbCWS[1], bbCWS[2] )); ; pCb->BoundingBoxHalfWorldSpace = XMLoadFloat3(&XMFLOAT3( bbHWS[0], bbHWS[1], bbHWS[2] )); ; pCb->BoundingBoxCenterObjectSpace = XMLoadFloat3(&XMFLOAT3( bbCOS[0], bbCOS[1], bbCOS[2] )); ; pCb->BoundingBoxHalfObjectSpace = XMLoadFloat3(&XMFLOAT3( bbHOS[0], bbHOS[1], bbHOS[2] )); ; // Shadow camera XMMATRIX shadowView, shadowProjection; CPUTCamera *pShadowCamera = gpSample->GetShadowCamera(); if( pShadowCamera ) { shadowView = XMMATRIX((float*)pShadowCamera->GetViewMatrix()); shadowProjection = XMMATRIX((float*)pShadowCamera->GetProjectionMatrix()); pCb->LightWorldViewProjection = world * shadowView * shadowProjection; } } pContext->Unmap(mpModelConstantBuffer,0); }
// Updates the cameras matrices void CCamera::UpdateViewMatrix() { if ((mSetting == ECameraSetting::FirstPerson || mSetting == ECameraSetting::ThirdPerson) && mParent == NULL) { mSetting = ECameraSetting::FreeRoam; } switch (mSetting) { case ECameraSetting::ThirdPerson: { // Add first and third person camera angles mWorldMat = mParent->GetMatrix( false ); mPos.x = mWorldMat._41; mPos.y = mWorldMat._42; mPos.z = mWorldMat._43; MoveLocalX( mOffset.x ); MoveY( mOffset.y ); MoveLocalZ( mOffset.z ); RotateLocalX( D3DXToRadian( 15 ) ); break; } case ECameraSetting::FirstPerson: { // Add first and third person camera angles mWorldMat = mParent->GetMatrix( false ); mPos.x = mWorldMat._41; mPos.y = mWorldMat._42; mPos.z = mWorldMat._43; MoveLocalX( mOffset.x ); MoveY( mOffset.y ); MoveLocalZ( mOffset.z ); break; } } if (mSetting != ECameraSetting::BirdsEye) { mWorldMat._41 = mPos.x; mWorldMat._42 = mPos.y; mWorldMat._43 = mPos.z; } // The rendering pipeline actually needs the inverse of the // camera world matrix - called the view matrix. XMVECTOR vector = XMVECTOR(); CXMMATRIX world = XMMATRIX( mWorldMat ); mView = XMMatrixInverse( &vector, world ); }
DirectX::XMMATRIX GetShow2DMatrix(int nWidth, int nHegith) { // Transform NDC space [-1,+1]^2 to texture space [0,1]^2 XMMATRIX toTexSpace( 0.5f * nWidth, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f * nHegith, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f * nWidth, 0.5f * nHegith, 0.0f, 1.0f); return XMMatrixInverse(NULL, toTexSpace); }
Matrix inverse(float* determinant = nullptr) const { XMVECTOR det; XMMATRIX mat = XMMatrixInverse(&det, *this); if (determinant) { *determinant = XMVectorGetX(det); } return static_cast<Matrix>(mat); }
// Returns the inverse transpose. XMMATRIX InverseTranspose(CXMMATRIX M) { // Inverse-transpose is just applied to normals. So zero out // translation row so that it doesn't get into our inverse-transpose // calculation--we don't want the inverse-transpose of the translation. XMMATRIX A = M; A.r[3] = XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f); XMVECTOR det = XMMatrixDeterminant(A); return XMMatrixTranspose(XMMatrixInverse(&det, A)); }
void AnimationPlayer::StartClip(AnimationClip& clip) { mCurrentClip = &clip; mCurrentTime = 0.0f; mCurrentKeyframe = 0; mIsPlayingClip = true; XMMATRIX inverseRootTransform = XMMatrixInverse(&XMMatrixDeterminant(mModel->RootNode()->TransformMatrix()), mModel->RootNode()->TransformMatrix()); XMStoreFloat4x4(&mInverseRootTransform, inverseRootTransform); GetBindPose(*(mModel->RootNode())); }
uint32_t Physics::exe_ob(uint32_t const& _x, uint32_t const& _y) const { XMVECTOR _pocz, _pocz1, _kier, _kier1; comp_ray_click(_pocz, _kier, _x, _y); float _t = 1000.0f, _t1; uint32_t _uch_wybr = 0x80000000; for(uint32_t _uch_ob = 0; _uch_ob < graph_par.no.wez_poj(); ++_uch_ob) { if(graph_par.no.sprawdz_pusty(_uch_ob)) continue; _pocz1 = XMVector3TransformCoord(_pocz, XMMatrixInverse( &XMVectorSet(0,0,0,0), XMLoadFloat4x4(&phys_par.mtx_world[graph_par.no[_uch_ob]]) )); _kier1 = XMVector3TransformNormal(_kier, XMMatrixInverse( &XMVectorSet(0,0,0,0), XMLoadFloat4x4(&phys_par.mtx_world[graph_par.no[_uch_ob]]) )); _t1 = comp_ray_ob(_pocz1, _kier1, graph_par.no[_uch_ob]); if(_t1 < _t) { _t = _t1; _uch_wybr = _uch_ob; } } return _uch_wybr; }