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 );
}
// --[ 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;
}
// --[ 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);
}
// --[ 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);
}
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;
}
void ZModInit_CGsp()
{
ZTvarp zv = ZAlloc(ZTvar,450);
ADD_CLASS(ZBox,"Box");
ADD_CLASS(ZCapsule,"Capsule");
ADD_CLASS(ZChamferCyl,"ChamferCyl");
ADD_CLASS(ZCone,"Cone");
ADD_CLASS(ZCylinder,"Cylinder");
ADD_CLASS(ZLathe,"Lathe");
ADD_CLASS(ZPlane,"Plane");
ADD_CLASS(ZPyramid,"Pyramid");
ADD_CLASS(ZSphere,"Sphere");
ADD_CLASS(ZSpindle,"Spindle");
ADD_CLASS(ZSpring,"Spring");
ADD_CLASS(ZTorus,"Torus");
ADD_CLASS(ZTube,"Tube");
ADD_CLASS(ZBevel,"Bevel");
ADD_CLASS(ZExtrude,"Extrude");
ADD_CLASS(ZOutline,"Outline");
ADD_CLASS(ZBend,"Bend");
ADD_CLASS(ZBulge,"Bulge");
ADD_CLASS(ZCylindrical_Wave,"Cylindrical_Wave");
ADD_CLASS(ZLinear_Wave,"Linear_Wave");
//ADD_CLASS(ZMorph,"Morph");
//ADD_CLASS(ZNoise,"Noise");
ADD_CLASS(ZSkew,"Skew");
ADD_CLASS(ZSmooth,"Smooth");
ADD_CLASS(ZSpherify,"Spherify");
ADD_CLASS(ZSqueeze,"Squeeze");
ADD_CLASS(ZStretch,"Stretch");
ADD_CLASS(ZTaper,"Taper");
ADD_CLASS(ZTriangulate,"Triangulate");
ADD_CLASS(ZTwist,"Twist");
ADD_CLASS(ZRigidBodySimulation,"PhysicsSimulation");
ADD_CLASS(ZKeyFrame,"KeyFrameAnimation");
ZTvarS zvs;
ZTOInstance zin;
ADD_CLASS(ZAxis ,"__ZAxis");
ADD_VAR( ZAxis (X_ax) , _ZC("XAxis") );
ADD_VAR( ZAxis (Y_ax) , _ZC("YAxis") );
ADD_VAR( ZAxis (Z_ax) , _ZC("ZAxis") );
ADD_CLASS(ZMath ,"__Math");
ADD_CLASS(ZMatrix ,"__Matrix");
ADD_VAR( ZMath () , _ZC("ZMath") );
ADD_VAR( ZMatrix () , _ZC("ZMatrix") );
ADD_VAR( ZBulgeType (BRadial) , _ZC("BRadial") );
ADD_VAR( ZBulgeType (BLinear) , _ZC("BLinear") );
ADD_CLASS(ZBulgeType,"ZBulgeType");
ADD_CLASS(ZPoint ,"ZPoint");
ADD_CLASS(ZFile ,"File");
}
// --[ 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());
}
