MStatus moveContext::doDrag( MEvent & event )
{
MStatus stat;
stat = MPxSelectionContext::doDrag( event );
// If we are not in selecting mode (i.e. an object has been selected)
// then do the translation.
//
if ( !isSelecting() ) {
event.getPosition( endPos_x, endPos_y );
MPoint endW, startW;
MVector vec;
view.viewToWorld( startPos_x, startPos_y, startW, vec );
view.viewToWorld( endPos_x, endPos_y, endW, vec );
downButton = event.mouseButton();
// We reset the the move vector each time a drag event occurs
// and then recalculate it based on the start position.
//
cmd->undoIt();
switch( currWin )
{
case TOP:
switch ( downButton )
{
case MEvent::kMiddleMouse :
cmd->setVector( endW.x - startW.x, 0.0, 0.0 );
break;
case MEvent::kLeftMouse :
default:
cmd->setVector( endW.x - startW.x, 0.0,
endW.z - startW.z );
break;
}
break;
case FRONT:
switch ( downButton )
{
case MEvent::kMiddleMouse :
cmd->setVector( endW.x - startW.x, 0.0, 0.0 );
break;
case MEvent::kLeftMouse :
default:
cmd->setVector( endW.x - startW.x,
endW.y - startW.y, 0.0 );
break;
}
break;
case SIDE:
switch ( downButton )
{
case MEvent::kMiddleMouse :
cmd->setVector( 0.0, 0.0, endW.z - startW.z );
break;
case MEvent::kLeftMouse :
default:
cmd->setVector( 0.0, endW.y - startW.y,
endW.z - startW.z );
break;
}
break;
case PERSP:
break;
}
stat = cmd->redoIt();
view.refresh( true );
}
return stat;
}
MStatus MannequinMoveManipulator::doPress(M3dView& view) {
getPointValue(_translateIndex, false, _opValueBegin);
GLuint activeAxis;
glActiveName(activeAxis);
if (activeAxis == _glPickableItem + 0) {
_opAxis = _x;
_opAxisIndex = 0;
} else if (activeAxis == _glPickableItem + 1) {
_opAxis = _y;
_opAxisIndex = 1;
} else if (activeAxis == _glPickableItem + 2) {
_opAxis = _z;
_opAxisIndex = 2;
} else {
_opAxis = MVector::zero;
_opValid = false;
return MS::kUnknownParameter;
}
_opOrigin = _origin;
// Determine the translation "plane"; it is orthogonal to the axis and faces
// the view as best as possible.
short originX, originY;
view.worldToView(_opOrigin, originX, originY);
MPoint rayNear;
MVector dirToOrigin;
view.viewToWorld(originX, originY, rayNear, dirToOrigin);
MVector dirInPlane = dirToOrigin ^ _opAxis;
_opPlaneNormal = dirInPlane ^ _opAxis;
// Determine where the current mouse ray hits the plane.
MPoint rayOrigin;
MVector rayDirection;
mouseRayWorld(rayOrigin, rayDirection);
MPoint isect;
bool didIsect = Util::rayPlaneIntersection(rayOrigin,
rayDirection,
_opOrigin,
_opPlaneNormal,
&isect);
if (!didIsect) {
_opValid = false;
return MS::kUnknownParameter;
}
_opHitBegin = isect;
_opValid = true;
// We need to calculate the handle directions in parent space. This is
// because the handle positions align with the child pivot rotation, so they
// DO NOT correspond to the child's X, Y, and Z-position, which are
// indicated in terms of the parent's coordinate space.
MMatrix parentInverse = _parentXform.asMatrixInverse();
_xInParentSpace = _x * parentInverse;
_yInParentSpace = _y * parentInverse;
_zInParentSpace = _z * parentInverse;
return MS::kSuccess;
}
MStatus sgCurveEditBrush_context::editCurve( MDagPath dagPathCurve,
int beforeX, int beforeY, int currentX, int currentY, float radius,
const MDoubleArray& dArrLength, MPointArray &points )
{
MStatus status;
if( radius < 0 ) return MS::kSuccess;
MDagPath dagPathCam;
M3dView view = M3dView::active3dView( &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
view.getCamera( dagPathCam );
MPoint camPos = dagPathCam.inclusiveMatrix()[3];
MVector vCamUp = dagPathCam.inclusiveMatrix()[1];
vCamUp.normalize();
radius *= .05;
MPoint nearClipBefore;
MPoint farClipBefore;
view.viewToWorld( beforeX, beforeY, nearClipBefore, farClipBefore );
MVector rayBefore = nearClipBefore - camPos;
rayBefore.normalize();
rayBefore *= 20;
MPoint posBefore = rayBefore + camPos;
MPoint nearClipCurrent;
MPoint farClipCurrent;
view.viewToWorld( currentX, currentY, nearClipCurrent, farClipCurrent );
MVector rayCurrent = nearClipCurrent - camPos;
rayCurrent.normalize();
rayCurrent *= 20;
MPoint posCurrent = rayCurrent + camPos;
MVector vMove = posCurrent - posBefore;
MMatrix mtxCurve = dagPathCurve.inclusiveMatrix();
MFnNurbsCurve fnCurve( dagPathCurve );
fnCurve.getCVs( points );
for( int i=0; i< points.length(); i++ )
{
points[i] *= mtxCurve;
}
for( int i=1; i< points.length(); i++ )
{
MPoint cuPoint = points[i];
MVector vPoint = cuPoint - camPos;
MVector projV = ( vPoint * rayBefore )/( pow( rayBefore.length(), 2 ) )* rayBefore;
MVector vertical = vPoint - projV;
float radiusForPoint = vertical.length() / projV.length();
if( radius < radiusForPoint )
continue;
MPoint parentPoint = points[i-1];
MVector vCurveDirection = cuPoint - parentPoint;
double vDirLength = vCurveDirection.length();
MVector vEditDirection = vCurveDirection + vMove/rayBefore.length()*projV.length();
double dotEdit = vCurveDirection.normal() * vEditDirection.normal();
if( dotEdit < 0 ) continue;
vEditDirection = vEditDirection * dotEdit + vCurveDirection*( 1-dotEdit );
MVector vEditLength = vEditDirection / vEditDirection.length() * vCurveDirection.length();
MVector vEdit = (vEditLength - vCurveDirection) * pow((double)(1-radiusForPoint/radius), 1 );
points[i] += vEdit;
for( int j=i+1; j< points.length(); j++ )
{
MPoint beforePoint = points[j];
MPoint pPoint = points[j-1];
MPoint beforePPoint = pPoint - vEdit;
MVector vBefore = points[j] - beforePPoint;
MVector vAfter = points[j] - pPoint;
MVector vCurrent = vAfter.normal() * dArrLength[j];
points[j] = vCurrent + pPoint;
vEdit = points[j] - beforePoint;
}
}
MMatrix invMtxCurve = mtxCurve.inverse();
for( int i=0; i< points.length(); i++ )
{
points[i] *= invMtxCurve;
}
fnCurve.setCVs( points );
fnCurve.updateCurve();
return MS::kSuccess;
}
