void Camera::buildFrustumPlanes() { D3DXMATRIX VP = m_view * m_proj; D3DXVECTOR4 col0(VP(0, 0), VP(1, 0), VP(2, 0), VP(3, 0)); D3DXVECTOR4 col1(VP(0, 1), VP(1, 1), VP(2, 1), VP(3, 1)); D3DXVECTOR4 col2(VP(0, 2), VP(1, 2), VP(2, 2), VP(3, 2)); D3DXVECTOR4 col3(VP(0, 3), VP(1, 3), VP(2, 3), VP(3, 3)); // Planes face inward. mFrustumPlanes[0] = (D3DXPLANE)(col2); // near mFrustumPlanes[1] = (D3DXPLANE)(col3 - col2); // far mFrustumPlanes[2] = (D3DXPLANE)(col3 + col0); // left mFrustumPlanes[3] = (D3DXPLANE)(col3 - col0); // right mFrustumPlanes[4] = (D3DXPLANE)(col3 - col1); // top mFrustumPlanes[5] = (D3DXPLANE)(col3 + col1); // bottom for (int i = 0; i < 6; i++) D3DXPlaneNormalize(&mFrustumPlanes[i], &mFrustumPlanes[i]); }
void FrustumPlanes::Set(const MATRIX &WorldViewProj) { // Left clipping plane Planes[0].a = WorldViewProj._14 + WorldViewProj._11; Planes[0].b = WorldViewProj._24 + WorldViewProj._21; Planes[0].c = WorldViewProj._34 + WorldViewProj._31; Planes[0].d = WorldViewProj._44 + WorldViewProj._41; D3DXPlaneNormalize( &Planes[0], &Planes[0] ); // Right clipping plane Planes[1].a = WorldViewProj._14 - WorldViewProj._11; Planes[1].b = WorldViewProj._24 - WorldViewProj._21; Planes[1].c = WorldViewProj._34 - WorldViewProj._31; Planes[1].d = WorldViewProj._44 - WorldViewProj._41; D3DXPlaneNormalize( &Planes[1], &Planes[1] ); // Top clipping plane Planes[2].a = WorldViewProj._14 - WorldViewProj._12; Planes[2].b = WorldViewProj._24 - WorldViewProj._22; Planes[2].c = WorldViewProj._34 - WorldViewProj._32; Planes[2].d = WorldViewProj._44 - WorldViewProj._42; D3DXPlaneNormalize( &Planes[2], &Planes[2] ); // Bottom clipping plane Planes[3].a = WorldViewProj._14 + WorldViewProj._12; Planes[3].b = WorldViewProj._24 + WorldViewProj._22; Planes[3].c = WorldViewProj._34 + WorldViewProj._32; Planes[3].d = WorldViewProj._44 + WorldViewProj._42; D3DXPlaneNormalize( &Planes[3], &Planes[3] ); // Near clipping plane Planes[4].a = WorldViewProj._13; Planes[4].b = WorldViewProj._23; Planes[4].c = WorldViewProj._33; Planes[4].d = WorldViewProj._43; D3DXPlaneNormalize( &Planes[4], &Planes[4] ); // Far clipping plane Planes[5].a = WorldViewProj._14 - WorldViewProj._13; Planes[5].b = WorldViewProj._24 - WorldViewProj._23; Planes[5].c = WorldViewProj._34 - WorldViewProj._33; Planes[5].d = WorldViewProj._44 - WorldViewProj._43; D3DXPlaneNormalize( &Planes[5], &Planes[5] ); }
//反射平面を作ります。 FbxAMatrix* D3DXMatrixReflect_Fixed(__inout FbxAMatrix *pOut, __in const D3DXPLANE *pPlane) { D3DXPLANE P; D3DXPlaneNormalize(&P, pPlane); pOut->mData[0][0] = -2.0f * P.a * P.a + 1.0f; pOut->mData[0][1] = -2.0f * P.b * P.a; pOut->mData[0][2] = -2.0f * P.c * P.a; pOut->mData[0][3] = 0.0f; pOut->mData[1][0] = -2.0f * P.a * P.b; pOut->mData[1][1] = -2.0f * P.b * P.b + 1.0f; pOut->mData[1][2] = -2.0f * P.c * P.b; pOut->mData[1][3] = 0.0f; pOut->mData[2][0] = -2.0f * P.a * P.c; pOut->mData[2][1] = -2.0f * P.b * P.c; pOut->mData[2][2] = -2.0f * P.c * P.c + 1.0f; pOut->mData[2][3] = 0.0f; pOut->mData[3][0] = -2.0f * P.a * P.d; pOut->mData[3][1] = -2.0f * P.b * P.d; pOut->mData[3][2] = -2.0f * P.c * P.d; pOut->mData[3][3] = 1.0f; return pOut; }
void CFrustum::Construct( float depth, Matrix4 &matrixProjectionScreen ) { Matrix4 matrix; matrix = matrixProjectionScreen; planes[0].a = matrix.n41 - matrix.n11; planes[0].b = matrix.n42 - matrix.n12; planes[0].c = matrix.n43 - matrix.n13; planes[0].d = matrix.n44 - matrix.n14; D3DXPlaneNormalize(&planes[0], &planes[0]); planes[1].a = matrix.n41 + matrix.n11; planes[1].b = matrix.n42 + matrix.n12; planes[1].c = matrix.n43 + matrix.n13; planes[1].d = matrix.n44 + matrix.n14; D3DXPlaneNormalize(&planes[1], &planes[1]); planes[2].a = matrix.n41 + matrix.n21; planes[2].b = matrix.n42 + matrix.n22; planes[2].c = matrix.n43 + matrix.n23; planes[2].d = matrix.n44 + matrix.n24; D3DXPlaneNormalize(&planes[2], &planes[2]); planes[3].a = matrix.n41 - matrix.n21; planes[3].b = matrix.n42 - matrix.n22; planes[3].c = matrix.n43 - matrix.n23; planes[3].d = matrix.n44 - matrix.n24; D3DXPlaneNormalize(&planes[3], &planes[3]); planes[4].a = matrix.n41 + matrix.n31; planes[4].b = matrix.n42 + matrix.n32; planes[4].c = matrix.n43 + matrix.n33; planes[4].d = matrix.n44 + matrix.n34; D3DXPlaneNormalize(&planes[4], &planes[4]); planes[5].a = matrix.n41 - matrix.n31; planes[5].b = matrix.n42 - matrix.n32; planes[5].c = matrix.n43 - matrix.n33; planes[5].d = matrix.n44 - matrix.n34; D3DXPlaneNormalize(&planes[5], &planes[5]); }
HRESULT KG3DRotationCoordinateOld::RotateBegin() { //m_matEntityWorld = m_EntityList.GetWorldMatrix(); { D3DXVECTOR3 vCenter(0,0,0); KSF::GetSelectionCenter(m_pAttachScene->GetSelectionTool(), vCenter); D3DXMatrixTranslation(&m_matEntityWorld, vCenter.x, vCenter.y, vCenter.z); } m_vBeginCross.x = m_matEntityWorld._41; m_vBeginCross.y = m_matEntityWorld._42; m_vBeginCross.z = m_matEntityWorld._43; m_vPrevCross = m_vBeginCross; HRESULT hResult = E_FAIL; HRESULT hRetCode = E_FAIL; D3DXVECTOR3 vOrg; D3DXVECTOR3 vDir; D3DXMATRIX matWorldInv; D3DXVECTOR3 vCrossXZ; D3DXVECTOR3 vCrossYZ; D3DXVECTOR3 vCrossXY; D3DXPLANE planeXZ; D3DXPLANE planeXY; D3DXPLANE planeYZ; D3DXVECTOR3 vPoint = D3DXVECTOR3(m_matCoord._41, m_matCoord._42, m_matCoord._43); D3DXVECTOR3 vNorXZ = D3DXVECTOR3(m_matCoord._21, m_matCoord._22, m_matCoord._23); D3DXVECTOR3 vNorXY = D3DXVECTOR3(m_matCoord._31, m_matCoord._32, m_matCoord._33); D3DXVECTOR3 vNorYZ = D3DXVECTOR3(m_matCoord._11, m_matCoord._12, m_matCoord._13); D3DXVECTOR3 vCross; IEKG3DSceneOutputWnd *piCurOutputWnd = NULL; KG_PROCESS_ERROR(m_dwCurrSelCoord != 0xFFFFFFFF); //KG_PROCESS_ERROR(m_pAttachScene); //KG_PROCESS_ERROR(m_EntityList.GetSize()); _ASSERTE(NULL != m_pAttachScene); KG_PROCESS_ERROR(0 != m_pAttachScene->GetSelectionTool().GetSelectionCount()); hRetCode = m_pAttachScene->GetCurOutputWnd(&piCurOutputWnd); KGLOG_COM_PROCESS_ERROR(hRetCode); piCurOutputWnd->GetPickRay(&vOrg, &vDir, NULL); D3DXPlaneFromPointNormal( &planeXZ, &vPoint, &vNorXZ ); D3DXPlaneFromPointNormal( &planeXY, &vPoint, &vNorXY ); D3DXPlaneFromPointNormal( &planeYZ, &vPoint, &vNorYZ ); D3DXPlaneNormalize(&planeYZ, &planeYZ); D3DXPlaneNormalize(&planeXZ, &planeXZ); D3DXPlaneNormalize(&planeXY, &planeXY); switch (m_dwCurrSelCoord) { case 0 : // y KG_PROCESS_ERROR( D3DXPlaneIntersectLine( &vCross, &planeXZ, &vOrg, &(vOrg + vDir * 10000000.0f) ) ); m_vPrevCross = vCross; m_currSelPane = planeXZ; m_currSelNormal = vNorXZ; break; case 1 : // x KG_PROCESS_ERROR( D3DXPlaneIntersectLine( &vCross, &planeYZ, &vOrg, &(vOrg + vDir * 10000000.0f) ) ); m_vPrevCross = vCross; m_currSelPane = planeYZ; m_currSelNormal = vNorYZ; break; case 2 : // z KG_PROCESS_ERROR( D3DXPlaneIntersectLine( &vCross, &planeXY, &vOrg, &(vOrg + vDir * 10000000.0f) ) ); m_vPrevCross = vCross; m_currSelPane = planeXY; m_currSelNormal = vNorXY; break; default : ASSERT(FALSE); break; } m_vBeginCross = m_vPrevCross; m_fAngelX = 0.0f; m_fAngelY = 0.0f; m_fAngelZ = 0.0f; m_nMoveFlag = TRUE; hResult = S_OK; Exit0: return hResult; }
void DxManager::CalculateCulling() { D3DXMATRIX view = this->camera->GetViewMatrix(); D3DXMATRIX proj = this->camera->GetProjectionMatrix(); /* float zMinimum = -proj._43 / proj._33; float r = this->params.FarClip / (this->params.FarClip - zMinimum); proj._33 = r; proj._43 = -r * zMinimum; */ D3DXMATRIX VP; D3DXMatrixMultiply(&VP, &view, &proj); // Calculate near plane of frustum. FrustrumPlanes[0].a = VP._14 + VP._13; FrustrumPlanes[0].b = VP._24 + VP._23; FrustrumPlanes[0].c = VP._34 + VP._33; FrustrumPlanes[0].d = VP._44 + VP._43; D3DXPlaneNormalize(&FrustrumPlanes[0], &FrustrumPlanes[0]); // Calculate far plane of frustum. FrustrumPlanes[1].a = VP._14 - VP._13; FrustrumPlanes[1].b = VP._24 - VP._23; FrustrumPlanes[1].c = VP._34 - VP._33; FrustrumPlanes[1].d = VP._44 - VP._43; D3DXPlaneNormalize(&FrustrumPlanes[1], &FrustrumPlanes[1]); // Calculate left plane of frustum. FrustrumPlanes[2].a = VP._14 + VP._11; FrustrumPlanes[2].b = VP._24 + VP._21; FrustrumPlanes[2].c = VP._34 + VP._31; FrustrumPlanes[2].d = VP._44 + VP._41; D3DXPlaneNormalize(&FrustrumPlanes[2], &FrustrumPlanes[2]); // Calculate right plane of frustum. FrustrumPlanes[3].a = VP._14 - VP._11; FrustrumPlanes[3].b = VP._24 - VP._21; FrustrumPlanes[3].c = VP._34 - VP._31; FrustrumPlanes[3].d = VP._44 - VP._41; D3DXPlaneNormalize(&FrustrumPlanes[3], &FrustrumPlanes[3]); // Calculate top plane of frustum. FrustrumPlanes[4].a = VP._14 - VP._12; FrustrumPlanes[4].b = VP._24 - VP._22; FrustrumPlanes[4].c = VP._34 - VP._32; FrustrumPlanes[4].d = VP._44 - VP._42; D3DXPlaneNormalize(&FrustrumPlanes[4], &FrustrumPlanes[4]); // Calculate bottom plane of frustum. FrustrumPlanes[5].a = VP._14 + VP._12; FrustrumPlanes[5].b = VP._24 + VP._22; FrustrumPlanes[5].c = VP._34 + VP._32; FrustrumPlanes[5].d = VP._44 + VP._42; D3DXPlaneNormalize(&FrustrumPlanes[5], &FrustrumPlanes[5]); //Terrain for(int i = 0; i < this->terrains.size(); i++) { Terrain* terr = this->terrains.get(i); float scale = max(terr->GetScale().x, max(terr->GetScale().y, terr->GetScale().z)); if(pe.FrustrumVsSphere(this->FrustrumPlanes, terr->GetBoundingSphere(), terr->GetWorldMatrix(), scale)) { terr->SetCulled(false); } else { terr->SetCulled(true); } } //Static meshes for(int i = 0; i < this->objects.size(); i++) { StaticMesh* ms = this->objects.get(i); MaloW::Array<MeshStrip*>* strips = ms->GetStrips(); for(int u = 0; u < strips->size(); u++) { MeshStrip* s = strips->get(u); float scale = max(ms->GetScaling().x, max(ms->GetScaling().y, ms->GetScaling().z)); if(pe.FrustrumVsSphere(this->FrustrumPlanes, s->GetBoundingSphere(), ms->GetWorldMatrix(), scale)) { s->SetCulled(false); } else { s->SetCulled(true); } } } //Animated meshes for(int i = 0; i < this->animations.size(); i++) { AnimatedMesh* ms = this->animations.get(i); MeshStrip* s = ms->GetStrips()->get(0); float scale = max(ms->GetScaling().x, max(ms->GetScaling().y, ms->GetScaling().z)); if(pe.FrustrumVsSphere(this->FrustrumPlanes, s->GetBoundingSphere(), ms->GetWorldMatrix(), scale)) { s->SetCulled(false); } else { s->SetCulled(true); } } }
void Camera::ConstructViewFrustum(ViewFrustum& frustum) { float zMinimum, r; D3DXMATRIX matrix; // Calculate the minimum Z distance in the frustum. zMinimum = -this->projectionMatrix._43 / this->projectionMatrix._33; r = this->projFar / (this->projFar - zMinimum); this->projectionMatrix._33 = r; this->projectionMatrix._43 = -r * zMinimum; // Create the frustum matrix from the view matrix and updated projection matrix. D3DXMatrixMultiply(&matrix, &this->viewMatrix, &this->projectionMatrix); // Calculate near plane of frustum. frustum.planes[0].a = matrix._14 + matrix._13; frustum.planes[0].b = matrix._24 + matrix._23; frustum.planes[0].c = matrix._34 + matrix._33; frustum.planes[0].d = matrix._44 + matrix._43; D3DXPlaneNormalize(&frustum.planes[0], &frustum.planes[0]); // Calculate far plane of frustum. frustum.planes[1].a = matrix._14 - matrix._13; frustum.planes[1].b = matrix._24 - matrix._23; frustum.planes[1].c = matrix._34 - matrix._33; frustum.planes[1].d = matrix._44 - matrix._43; D3DXPlaneNormalize(&frustum.planes[1], &frustum.planes[1]); // Calculate left plane of frustum. frustum.planes[2].a = matrix._14 + matrix._11; frustum.planes[2].b = matrix._24 + matrix._21; frustum.planes[2].c = matrix._34 + matrix._31; frustum.planes[2].d = matrix._44 + matrix._41; D3DXPlaneNormalize(&frustum.planes[2], &frustum.planes[2]); // Calculate right plane of frustum. frustum.planes[3].a = matrix._14 - matrix._11; frustum.planes[3].b = matrix._24 - matrix._21; frustum.planes[3].c = matrix._34 - matrix._31; frustum.planes[3].d = matrix._44 - matrix._41; D3DXPlaneNormalize(&frustum.planes[3], &frustum.planes[3]); // Calculate top plane of frustum. frustum.planes[4].a = matrix._14 - matrix._12; frustum.planes[4].b = matrix._24 - matrix._22; frustum.planes[4].c = matrix._34 - matrix._32; frustum.planes[4].d = matrix._44 - matrix._42; D3DXPlaneNormalize(&frustum.planes[4], &frustum.planes[4]); // Calculate bottom plane of frustum. frustum.planes[5].a = matrix._14 + matrix._12; frustum.planes[5].b = matrix._24 + matrix._22; frustum.planes[5].c = matrix._34 + matrix._32; frustum.planes[5].d = matrix._44 + matrix._42; D3DXPlaneNormalize(&frustum.planes[5], &frustum.planes[5]); //Calculate sphere around frustum for faster culling float length = this->projFar - this->projNear; float height = length*tan((float)D3DX_PI*0.5f*0.5f); float width = height*(800/600); D3DXVECTOR3 p(0.0f,0.0f, 1+length*0.5f); D3DXVECTOR3 q(width, height, length); D3DXVECTOR3 vDiff(p-q); frustum.sphere.radius = D3DXVec3Length(&vDiff); frustum.sphere.center = D3DXVECTOR3(this->positionX, this->positionY, this->positionZ) + (D3DXVECTOR3(this->GetLookAt().x - this->positionX, this->GetLookAt().y - this->positionY, this->GetLookAt().z - this->positionZ)*(length*0.5f)); }