// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : CVector3 Angles() // // - Purpose : Returns matrix's (x, y, z) rotation angles. // // ----------------------------------------------------------------------------- CVector3 CMatrix::Angles() const { float fAngleX = ZAxis().Angle(CVector3(0.0f, 0.0f, 1.0f)); float fAngleY = XAxis().Angle(CVector3(1.0f, 0.0f, 0.0f)); float fAngleZ = YAxis().Angle(CVector3(0.0f, 1.0f, 0.0f)); if(YAxis().Z() < 0) fAngleX += 180 - fAngleY; if(XAxis().Z() > 0) fAngleY += 180 - fAngleY; if(YAxis().X() > 0) fAngleZ += 180 - fAngleZ; return CVector3(fAngleX, fAngleY, fAngleZ); }
QMenu * ViewLightGL::createToolsMenu(QWidget * parent) { QMenu * menu = new QMenu(parent); QPixmap home(ViewerIcon::getPixmap(ViewerIcon::home)); QPixmap _light(ViewerIcon::getPixmap(ViewerIcon::light)); menu->addAction(home,tr("&Home"),this,SLOT(home()),Qt::CTRL+Qt::SHIFT+Qt::Key_H); menu->addAction(tr("on X axis"),this,SLOT(XAxis()),Qt::CTRL+Qt::SHIFT+Qt::Key_X); menu->addAction(tr("on Y axis"),this,SLOT(YAxis()),Qt::CTRL+Qt::SHIFT+Qt::Key_Y); menu->addAction(tr("on Z axis"),this,SLOT(ZAxis()),Qt::CTRL+Qt::SHIFT+Qt::Key_Z); menu->addSeparator(); QAction * idVisibility = menu->addAction(_light,tr("Visible"),this,SLOT(changeVisibility()),Qt::CTRL+Qt::SHIFT+Qt::Key_S); idVisibility->setCheckable( TRUE ); idVisibility->setChecked( isVisible() ); QObject::connect(this,SIGNAL(visibilityChanged( bool)),idVisibility,SLOT(setChecked(bool))); menu->addSeparator(); QAction * idLight = menu->addAction(_light, tr("&Enabled"), this, SLOT(toggleEnabled())); idLight->setCheckable(true); idLight->setChecked(isEnabled()); idLight->setWhatsThis(tr("<b>Light Rendering</b><br><br>" "Set <b>Light Rendering</b> enable/disable.<br><br>" "The Rendering will (not) take into account ligth source.<br><br>" "You can also use Menu <br><b>Tools > Renderer > Light</b><br>")); return menu; }
//----------------------------------------------------------------------------- // Purpose: // Input : *pRender - //----------------------------------------------------------------------------- void CGizmo::Render(CRender3D *pRender) { Vector XAxis( m_Position[0] + m_fAxisLength, m_Position[1], m_Position[2] ); Vector YAxis( m_Position[0], m_Position[1] + m_fAxisLength, m_Position[2] ); Vector ZAxis( m_Position[0], m_Position[1], m_Position[2] + m_fAxisLength ); static BoundBox UniformScaleBox; Vector Mins; Vector Maxs; Mins[0] = m_Position[0] - m_fAxisLength * 0.1; Mins[1] = m_Position[1] - m_fAxisLength * 0.1; Mins[2] = m_Position[2] - m_fAxisLength * 0.1; Maxs[0] = m_Position[0] + m_fAxisLength * 0.1; Maxs[1] = m_Position[1] + m_fAxisLength * 0.1; Maxs[2] = m_Position[2] + m_fAxisLength * 0.1; UniformScaleBox.ResetBounds(); UniformScaleBox.UpdateBounds(Mins, Maxs); pRender->BeginRenderHitTarget(this, GIZMO_HANDLE_UNIFORM_SCALE); //pRender->RenderBox(Mins, Maxs, BoxType_Solid, 200, 200, 200); pRender->EndRenderHitTarget(); pRender->SetRenderMode( RENDER_MODE_TEXTURED ); DrawGizmoAxis(pRender, m_Position, XAxis, 255, 0, 0, GIZMO_AXIS_X); DrawGizmoAxis(pRender, m_Position, YAxis, 0, 255, 0, GIZMO_AXIS_Y); DrawGizmoAxis(pRender, m_Position, ZAxis, 0, 0, 255, GIZMO_AXIS_Z); pRender->SetRenderMode( RENDER_MODE_DEFAULT ); }
//----------------------------------------------------------------------------- bool Matrix22::IsAxisNormal () const { Vector2D xAxis, yAxis; XAxis(xAxis); YAxis(yAxis); return (xAxis.IsNormal() && yAxis.IsNormal()); }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : void RemoveRotation() // // - Purpose : Removes matrix's rotation values. // // ----------------------------------------------------------------------------- void CMatrix::RemoveRotation() { float fLengthX = XAxis().Length(); float fLengthY = YAxis().Length(); float fLengthZ = ZAxis().Length(); SetXAxis(CVector3(fLengthX, 0.0f, 0.0f)); SetYAxis(CVector3(0.0f, fLengthY, 0.0f)); SetZAxis(CVector3(0.0f, 0.0f, fLengthZ)); }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : bool HasNegativeScale() // // - Purpose : Returns true if matrix has some negative scaling, otherwise // false. // // ----------------------------------------------------------------------------- bool CMatrix::HasNegativeScale() const { CVector3 xAxis = XAxis(); CVector3 yAxis = YAxis(); CVector3 zAxis = ZAxis(); CVector3 c0(xAxis.X(), yAxis.X(), zAxis.X()); CVector3 c1(xAxis.Y(), yAxis.Y(), zAxis.Y()); CVector3 c2(xAxis.Z(), yAxis.Z(), zAxis.Z()); return ((c0 ^ c1) * c2) < 0.0f ? true : false; }
//----------------------------------------------------------------------------- Matrix22& Matrix22::NormalAxis() { Vector2D xAxis, yAxis; XAxis(xAxis); YAxis(yAxis); xAxis.Normalize(); yAxis.Normalize(); this->Set(xAxis, yAxis); return *this; }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : void RemoveScale() // // - Purpose : Removes matrix's scale values. // // ----------------------------------------------------------------------------- void CMatrix::RemoveScale() { CVector3 xAxis = XAxis(); CVector3 yAxis = YAxis(); CVector3 zAxis = ZAxis(); xAxis.Normalize(); yAxis.Normalize(); zAxis.Normalize(); SetXAxis(xAxis); SetYAxis(yAxis); SetZAxis(zAxis); }
//----------------------------------------------------------------------------- Matrix22 Matrix22::AsNormalAxis() const { Vector2D xAxis, yAxis; XAxis(xAxis); YAxis(yAxis); xAxis.Normalize(); yAxis.Normalize(); Matrix22 m; m.Set(xAxis, yAxis); return m; }
//----------------------------------------------------------------------------- Matrix22 Matrix22::AsRightHanded() const { DIA_ASSERT(IsOrthogonal(), "Must be orthogonal"); DIA_ASSERT(IsAxisNormal(), "Axis are not normal"); if (IsRightHanded()) { return *this; } Vector2D xAxis, yAxis; XAxis(xAxis); YAxis(yAxis); Matrix22 m(yAxis, xAxis); return m; }
//----------------------------------------------------------------------------- Matrix22& Matrix22::RightHanded() { DIA_ASSERT(IsOrthogonal(), "Must be orthogonal"); DIA_ASSERT(IsAxisNormal(), "Axis are not normal"); if (IsRightHanded()) { return *this; } Vector2D xAxis, yAxis; XAxis(xAxis); YAxis(yAxis); this->Set(yAxis, xAxis); return *this; }
bool OBB::Intersect(OBB &b) { //Cheap Sphere-Sphere intersection test float l = D3DXVec3Length(&(b.m_pos - m_pos)); if (l > (b.m_radius + m_radius)) { return false; } //More expensive OBB-OBB intersection test D3DXMATRIX r1, r2, matB; D3DXMatrixRotationQuaternion(&r1, &m_rot); D3DXMatrixRotationQuaternion(&r2, &b.m_rot); D3DXMatrixInverse(&r1, NULL, &r1); D3DXMatrixMultiply(&matB, &r2, &r1); D3DXVECTOR4 vPosB; D3DXVec3Transform(&vPosB, &(b.m_pos - m_pos), &r1); D3DXVECTOR3 XAxis(matB._11,matB._21,matB._31); D3DXVECTOR3 YAxis(matB._12,matB._22,matB._32); D3DXVECTOR3 ZAxis(matB._13,matB._23,matB._33); //15 tests //1 (Ra)x if (fabs(vPosB.x) > m_size.x + b.m_size.x * fabs(XAxis.x) + b.m_size.y * fabs(XAxis.y) + b.m_size.z * fabs(XAxis.z)) return false; //2 (Ra)y if (fabs(vPosB.y) > m_size.y + b.m_size.x * fabs(YAxis.x) + b.m_size.y * fabs(YAxis.y) + b.m_size.z * fabs(YAxis.z)) return false; //3 (Ra)z if (fabs(vPosB.z) > m_size.z + b.m_size.x * fabs(ZAxis.x) + b.m_size.y * fabs(ZAxis.y) + b.m_size.z * fabs(ZAxis.z)) return false; //4 (Rb)x if (fabs(vPosB.x*XAxis.x+vPosB.y*YAxis.x+vPosB.z*ZAxis.x) > (b.m_size.x+m_size.x*fabs(XAxis.x) + m_size.y * fabs(YAxis.x) + m_size.z*fabs(ZAxis.x))) return false; //5 (Rb)y if (fabs(vPosB.x*XAxis.y+vPosB.y*YAxis.y+vPosB.z*ZAxis.y) > (b.m_size.y+m_size.x*fabs(XAxis.y) + m_size.y * fabs(YAxis.y) + m_size.z*fabs(ZAxis.y))) return false; //6 (Rb)z if (fabs(vPosB.x*XAxis.z+vPosB.y*YAxis.z+vPosB.z*ZAxis.z) > (b.m_size.z+m_size.x*fabs(XAxis.z) + m_size.y * fabs(YAxis.z) + m_size.z*fabs(ZAxis.z))) return false; //7 (Ra)x X (Rb)x if (fabs(vPosB.z*YAxis.x-vPosB.y*ZAxis.x) > m_size.y*fabs(ZAxis.x) + m_size.z*fabs(YAxis.x) + b.m_size.y*fabs(XAxis.z) + b.m_size.z*fabs(XAxis.y)) return false; //8 (Ra)x X (Rb)y if (fabs(vPosB.z*YAxis.y-vPosB.y*ZAxis.y) > m_size.y*fabs(ZAxis.y) + m_size.z*fabs(YAxis.y) + b.m_size.x*fabs(XAxis.z) + b.m_size.z*fabs(XAxis.x)) return false; //9 (Ra)x X (Rb)z if (fabs(vPosB.z*YAxis.z-vPosB.y*ZAxis.z) > m_size.y*fabs(ZAxis.z) + m_size.z*fabs(YAxis.z) + b.m_size.x*fabs(XAxis.y) + b.m_size.y*fabs(XAxis.x)) return false; //10 (Ra)y X (Rb)x if (fabs(vPosB.x*ZAxis.x-vPosB.z*XAxis.x) > m_size.x*fabs(ZAxis.x) + m_size.z*fabs(XAxis.x) + b.m_size.y*fabs(YAxis.z) + b.m_size.z*fabs(YAxis.y)) return false; //11 (Ra)y X (Rb)y if (fabs(vPosB.x*ZAxis.y-vPosB.z*XAxis.y) > m_size.x*fabs(ZAxis.y) + m_size.z*fabs(XAxis.y) + b.m_size.x*fabs(YAxis.z) + b.m_size.z*fabs(YAxis.x)) return false; //12 (Ra)y X (Rb)z if (fabs(vPosB.x*ZAxis.z-vPosB.z*XAxis.z) > m_size.x*fabs(ZAxis.z) + m_size.z*fabs(XAxis.z) + b.m_size.x*fabs(YAxis.y) + b.m_size.y*fabs(YAxis.x)) return false; //13 (Ra)z X (Rb)x if (fabs(vPosB.y*XAxis.x-vPosB.x*YAxis.x) > m_size.x*fabs(YAxis.x) + m_size.y*fabs(XAxis.x) + b.m_size.y*fabs(ZAxis.z) + b.m_size.z*fabs(ZAxis.y)) return false; //14 (Ra)z X (Rb)y if (fabs(vPosB.y*XAxis.y-vPosB.x*YAxis.y) > m_size.x*fabs(YAxis.y) + m_size.y*fabs(XAxis.y) + b.m_size.x*fabs(ZAxis.z) + b.m_size.z*fabs(ZAxis.x)) return false; //15 (Ra)z X (Rb)z if (fabs(vPosB.y*XAxis.z-vPosB.x*YAxis.z) > m_size.x*fabs(YAxis.z) + m_size.y*fabs(XAxis.z) + b.m_size.x*fabs(ZAxis.y) + b.m_size.y*fabs(ZAxis.x)) return false; return true; }
// --[ Method ]--------------------------------------------------------------- // // - Class : CMatrix // // - prototype : CVector Scale() // // - Purpose : Returns matrix's (x, y, z) scale values. // // ----------------------------------------------------------------------------- CVector3 CMatrix::Scale() const { return CVector3(XAxis().Length(), YAxis().Length(), ZAxis().Length()); }