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;
}
