MStatus customAttrCtx::doRelease( MEvent & event )
//
// Description
// This method is called when a mouse button is released while this context is
// the current context.
//
{
// Let the parent class handle the event.
MStatus stat = MPxSelectionContext::doRelease( event );
// If an object is selected, process the event if the middle mouse button
// was lifted.
if ( !isSelecting() ) {
if (event.mouseButton() == MEvent::kMiddleMouse)
{
event.getPosition( endPos_x, endPos_y );
// Delete the move command if we have moved less then 2 pixels
// otherwise call finalize to set up the journal and add the
// command to the undo queue.
//
if ( abs(startPos_x - endPos_x) < 2 ) {
delete cmd;
view.refresh( true );
}
else {
stat = cmd->finalize();
view.refresh( true );
}
setCursor(MCursor::defaultCursor);
}
}
return stat;
}
MStatus HairToolContext::doRelease( MEvent& event )
{
// only bother handling the release of a left mouse button.
if(event.mouseButton() != MEvent::kLeftMouse) {
return MPxContext::doRelease(event);
}
else if(!intersectionFound){
return MPxContext::doRelease(event);
}
else if(splinePoints.size() < 2){
return MPxContext::doRelease(event);
}
OverCoatNode::numOfSplinesCreated++;
MGlobal::executeCommand("print \" Intersection Detected \\n\"");
char curveCreation[8000];
sprintf(curveCreation, "curve", OverCoatNode::numOfSplinesCreated);
for(int i = 0; i < splinePoints.size(); i++){
char buffer[200];
sprintf(buffer, " -p %f %f %f", splinePoints[i].x, splinePoints[i].y, splinePoints[i].z);
strcat(curveCreation, buffer);
}
MString result;
MGlobal::executeCommand(curveCreation, result);
const char* curveName = result.asChar();
int splineCount;
sscanf(curveName, "curve%d", &splineCount);
char overCoatNodeCreation[200];
sprintf(overCoatNodeCreation, "createNode OverCoatNode -name OverCoatNode%d", splineCount);
MGlobal::executeCommand(overCoatNodeCreation);
char overCoatNodeSetAttrColor[200];
sprintf(overCoatNodeSetAttrColor, "setAttr OverCoatNode%d.color -type \"double3\" %f %f %f", splineCount, red, green, blue);
MGlobal::executeCommand(overCoatNodeSetAttrColor);
char overCoatNodeSetAttrThick[200];
sprintf(overCoatNodeSetAttrThick, "setAttr OverCoatNode%d.thick %f", splineCount, thick);
MGlobal::executeCommand(overCoatNodeSetAttrThick);
char overCoatNodeSetAttrBrush[200];
sprintf(overCoatNodeSetAttrBrush, "setAttr OverCoatNode%d.brush %d", splineCount, brush);
MGlobal::executeCommand(overCoatNodeSetAttrBrush);
char overCoatNodeSetAttrTrans[200];
sprintf(overCoatNodeSetAttrTrans, "setAttr OverCoatNode%d.transparency %f", splineCount, transparency);
MGlobal::executeCommand(overCoatNodeSetAttrTrans);
char overCoatNodeConnectAttr[200];
sprintf(overCoatNodeConnectAttr, "connectAttr curve%d.worldSpace OverCoatNode%d.spline", splineCount, splineCount);
MGlobal::executeCommand(overCoatNodeConnectAttr);
char overCoatNodeSetAttrSpacing[200];
sprintf(overCoatNodeSetAttrSpacing, "setAttr OverCoatNode%d.spacing %f", splineCount, spacing);
MGlobal::executeCommand(overCoatNodeSetAttrSpacing);
return MS::kSuccess;
}
MStatus customAttrCtx::doDrag( MEvent & event )
//
// Description
// This method is called when a mouse button is dragged while this context is
// the current context.
//
{
MStatus stat;
// If an object has been selected, then process the drag. Otherwise, pass the
// event on up to the parent class.
if ((!isSelecting()) && (event.mouseButton() == MEvent::kMiddleMouse)) {
event.getPosition( endPos_x, endPos_y );
// Undo the command to erase the previously set delta value from the
// node, set a new delta value in the command and redo the command to
// set the values in the node.
cmd->undoIt();
cmd->setDelta(endPos_x - startPos_x);
stat = cmd->redoIt();
view.refresh( true );
}
else
stat = MPxSelectionContext::doDrag( event );
return stat;
}
MStatus customAttrCtx::doPress( MEvent & event )
//
// Description
// This method is called when a mouse button is pressed while this context is
// the current context.
//
{
// Let the parent class handle the event first in case there is no object
// selected yet. The parent class will perform any necessary selection.
MStatus stat = MPxSelectionContext::doPress( event );
// If an object has been selected, then process the event. Otherwise,
// ignore it as there is nothing to do.
if ( !isSelecting() ) {
if (event.mouseButton() == MEvent::kMiddleMouse)
{
setCursor(MCursor::handCursor);
view = M3dView::active3dView();
// Create an instance of the customAttrCmd tool command and initialize
// its delta value to 0. As the mouse drags, the delta value will change.
// when the mouse is lifted, a final command will be constructed with the
// most recently set delta value and axis specifications.
cmd = (customAttrCmd *)newToolCommand();
cmd->setDelta(0.0);
event.getPosition( startPos_x, startPos_y );
// Determine the channel box attribute which will be operated on by the
// dragging motion and set the state of the command accordingly.
unsigned int i;
MStringArray result;
MGlobal::executeCommand(
"channelBox -q -selectedMainAttributes $gChannelBoxName", result);
for (i=0; i<result.length(); i++)
{
if (result[i] == customAttributeString)
{
cmd->setDragX();
break;
}
}
}
}
return stat;
}
MStatus HairToolContext::doPress( MEvent& event )
{
// if we have a left mouse click
if(event.mouseButton() == MEvent::kLeftMouse)
{
//Our Viewer
m_View = M3dView::active3dView();
//Get Screen click position
event.getPosition( m_storage[0], m_storage[1] );
screenPoints = vector<vec2>();
screenPoints.push_back(vec2(m_storage[0], m_storage[1]));
//char buffer[200];
//sprintf(buffer, "print \"%i, %i\\n\"", m_storage[0], m_storage[1]);
//MGlobal::executeCommand(buffer);
//Camera stuff
MPoint origin = MPoint();
MVector direction = MVector();
m_View.viewToWorld(m_storage[0], m_storage[1], origin, direction);
//Iterate through meshes in scene
bool intersection = false;
MPointArray points = MPointArray();
MIntArray polygonIds = MIntArray();
MItDag dagIter = MItDag(MItDag::kBreadthFirst, MFn::kInvalid);
for( ; !dagIter.isDone(); dagIter.next() ){
MDagPath dagPath;
dagIter.getPath(dagPath);
MFnDagNode dagNode( dagPath);
//Object cannot be intermediate, it must be a mesh
if( dagNode.isIntermediateObject() ) continue;
if( !dagPath.hasFn(MFn::kMesh) ) continue;
if( dagPath.hasFn(MFn::kTransform) ) continue;
MGlobal::executeCommand(MString("print \"node is a mesh \\n\""));
//MFnMesh mesh = MFnMesh(dagPath);
MFnMesh mesh(dagPath);
points = MPointArray();
polygonIds = MIntArray();
intersection = mesh.intersect(origin, direction, points, 1e-010, MSpace::kWorld, &polygonIds);
if(intersection){
break;
}
}
if(intersection){
intersectionFound = true;
MDagPath dagPath;
dagIter.getPath(dagPath);
// MFnMesh mesh = MFnMesh(dagPath);
MFnMesh mesh(dagPath);
//Polygon Normal
MVector polygonNormal;
mesh.getPolygonNormal(polygonIds[0], polygonNormal, MSpace::kWorld);
if(polygonNormal.normal().angle(direction.normal()) < 20.0f){
//polygonNormal = mesh.get
}
//Camera Right
m_View.getCamera(dagPath);
MFnCamera camera(dagPath);
MVector cameraRight = camera.rightDirection(MSpace::kWorld);
//Resulting Plane
//Point
point = points[0];
//Normal
normal = cameraRight^polygonNormal;
//pushback point
splinePoints = vector<MPoint>();
splinePoints.push_back(MPoint(points[0].x, points[0].y, points[0].z, points[0].w));
/*//Calculate Tvalue
tValue = (points[0].x - origin.x)/direction.x;*/
}
else{
intersectionFound = false;
MGlobal::executeCommand("print \" No Intersection \\n\"");
}
// yay!
return MS::kSuccess;
}
// just let the base class handle the event*/
return MPxContext::doPress(event);
}
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 grabUVContext::doDrag ( MEvent & event, MHWRender::MUIDrawManager& drawMgr, const MHWRender::MFrameContext& context)
{
if (event.mouseButton() != MEvent::kLeftMouse ||
!event.isModifierNone() )
return MS::kFailure;
MPxTexContext::doDrag(event, drawMgr, context);
short x, y;
event.getPosition( x, y );
fLastScreenPoint = fCurrentScreenPoint;
fCurrentScreenPoint = MPoint( x, y );
double xView, yView;
portToView(x, y, xView, yView); // pos at viewrect coordinate
fLastPoint = fCurrentPoint;
fCurrentPoint = MPoint( xView, yView, 0.0 );
if( fDragMode == kBrushSize )
{
double dis = fCurrentScreenPoint.distanceTo( fLastScreenPoint );
if ( fCurrentScreenPoint[0] > fLastScreenPoint[0] )
setSize( size() + float(dis) );
else
setSize( std::max( size() - float(dis), 0.01f ) );
}
else
{
fBrushCenterScreenPoint = MPoint( x, y );
MFloatArray uUVsExported;
MFloatArray vUVsExported;
const MVector vec = fCurrentPoint - fLastPoint;
if (!fCommand)
{
fCommand = (UVUpdateCommand *)(newToolCommand());
}
if (fCommand)
{
MFnMesh mesh(fDagPath);
MString currentUVSetName;
mesh.getCurrentUVSetName(currentUVSetName);
int nbUVs = mesh.numUVs(currentUVSetName);
MDoubleArray pinData;
MUintArray uvPinIds;
MDoubleArray fullPinData;
mesh.getPinUVs(uvPinIds, pinData, ¤tUVSetName);
int len = pinData.length();
fullPinData.setLength(nbUVs);
for (unsigned int i = 0; i < nbUVs; i++) {
fullPinData[i] = 0.0;
}
while( len-- > 0 ) {
fullPinData[uvPinIds[len]] = pinData[len];
}
MFloatArray uValues;
MFloatArray vValues;
float pinWeight = 0;
for (unsigned int i = 0; i < fCollectedUVs.length(); ++i)
{
float u, v;
MStatus bGetUV = mesh.getUV(fCollectedUVs[i], u, v, ¤tUVSetName);
if (bGetUV == MS::kSuccess)
{
pinWeight = fullPinData[fCollectedUVs[i]];
u += (float)vec[0]*(1-pinWeight);
v += (float)vec[1]*(1-pinWeight);
uValues.append( u );
vValues.append( v );
}
}
fCommand->setUVs( mesh.object(), fCollectedUVs, uValues, vValues, ¤tUVSetName );
}
}
return MS::kSuccess;
}
MStatus grabUVContext::doPress ( MEvent & event, MHWRender::MUIDrawManager& drawMgr, const MHWRender::MFrameContext& context)
{
if ( event.mouseButton() != MEvent::kLeftMouse ||
!event.isModifierNone() )
return MS::kFailure;
fInStroke = true;
MPxTexContext::doPress(event, drawMgr, context);
short x, y;
event.getPosition( x, y );
fCurrentScreenPoint = MPoint( x, y );
fLastScreenPoint = MPoint( x, y );
fBrushCenterScreenPoint = MPoint( x, y );
double xView, yView;
portToView(x, y, xView, yView); // pos at viewrect coordinate
double portW, portH;
portSize(portW, portH);
double left, right, bottom, top;
viewRect(left, right, bottom, top);
double sizeInView = portW < 1e-5 ? 0.0 : ( fBrushConfig.size() * (right - left) / portW );
double sizeInViewSquare = sizeInView * sizeInView;
if( fDragMode == kNormal )
{
fCollectedUVs.clear();
MStatus *returnStatus = NULL;
MSelectionMask mask = MSelectionMask::kSelectMeshUVs;
const bool bPickSingle = false;
MSelectionList selectionList;
bool bSelect = MPxTexContext::getMarqueeSelection( x - fBrushConfig.size(), y - fBrushConfig.size(),
x + fBrushConfig.size(), y + fBrushConfig.size(),
mask, bPickSingle, true, selectionList );
if (bSelect)
{
MObject component;
selectionList.getDagPath( 0, fDagPath, component );
fDagPath.extendToShape();
MFnMesh mesh(fDagPath);
MString currentUVSetName;
mesh.getCurrentUVSetName(currentUVSetName);
MIntArray UVsToTest;
if( component.apiType() == MFn::kMeshMapComponent )
{
MFnSingleIndexedComponent compFn( component );
compFn.getElements( UVsToTest );
for (unsigned int i = 0; i < UVsToTest.length(); ++i)
{
float u, v;
MStatus bGetUV = mesh.getUV(UVsToTest[i], u, v, ¤tUVSetName);
if (bGetUV == MS::kSuccess)
{
float distSquare = ( u - xView ) * ( u - xView ) + ( v - yView ) * ( v - yView );
if ( distSquare < sizeInViewSquare )
fCollectedUVs.append(UVsToTest[i]);
}
}
}
// position in view(world) space.
fLastPoint = MPoint( xView, yView, 0.0 );
fCurrentPoint = MPoint( xView, yView, 0.0 );
}
}
return MS::kSuccess;
}
