MStatus HairToolContext::doDrag( MEvent& event ) { if(intersectionFound){ //Our Viewer m_View = M3dView::active3dView(); //Get Screen click position event.getPosition( m_storage[0], m_storage[1] ); screenPoints.push_back(vec2(m_storage[0], m_storage[1])); //Camera stuff MPoint origin = MPoint(); MVector direction = MVector(); m_View.viewToWorld(m_storage[0], m_storage[1], origin, direction); float tValue = ((point - origin)*normal) / (direction * normal); MPoint newPoint = tValue*direction + origin; splinePoints.push_back(newPoint); //Draw GL curve m_View.beginXorDrawing(true, true, 1.0f, M3dView::kStippleDashed); glBegin(GL_LINE_STRIP ); for ( unsigned i = 0; i < screenPoints.size() ; i++ ){ glVertex2i( screenPoints[i][0], screenPoints[i][1] ); } glEnd(); m_View.endXorDrawing(); } return MPxContext::doDrag(event); }
void marqueeContext::doPressCommon( MEvent & event ) { // Figure out which modifier keys were pressed, and set up the // listAdjustment parameter to reflect what to do with the selected points. if (event.isModifierShift() || event.isModifierControl() ) { if ( event.isModifierShift() ) { if ( event.isModifierControl() ) { // both shift and control pressed, merge new selections listAdjustment = MGlobal::kAddToList; } else { // shift only, xor new selections with previous ones listAdjustment = MGlobal::kXORWithList; } } else if ( event.isModifierControl() ) { // control only, remove new selections from the previous list listAdjustment = MGlobal::kRemoveFromList; } } else { listAdjustment = MGlobal::kReplaceList; } // Extract the event information // event.getPosition( start_x, start_y ); }
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 marqueeContext::doDrag( MEvent & event ) // // Drag out the marquee (using OpenGL) // { #if CUSTOM_XOR_DRAW xorDraw XORdraw(&view); XORdraw.beginXorDrawing(); #else view.beginXorDrawing(); #endif if (fsDrawn) { // Redraw the marquee at its old position to erase it. drawMarqueeGL(); } fsDrawn = true; // Get the marquee's new end position. event.getPosition( last_x, last_y ); // Draw the marquee at its new position. drawMarqueeGL(); #if CUSTOM_XOR_DRAW XORdraw.endXorDrawing(); #else view.endXorDrawing(); #endif return MS::kSuccess; }
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 SelectRingContext2::doPress( MEvent &event ) { listAdjust = MGlobal::kReplaceList; // Determine which modifier keys were pressed if( event.isModifierShift() || event.isModifierControl() ) { if( event.isModifierShift() ) { if( event.isModifierControl() ) listAdjust = MGlobal::kAddToList; // Shift+Ctrl: Merge selection else listAdjust = MGlobal::kXORWithList; // Shift: Toggle selection (XOR) } else { if( event.isModifierControl() ) listAdjust = MGlobal::kRemoveFromList; // Ctrl: Remove selection } } // Get the position of the mouse click event.getPosition( pressX, pressY ); return MS::kSuccess; }
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 marqueeContext::doPress( MEvent & event ) // // Begin marquee drawing (using OpenGL) // Get the start position of the marquee // { // Figure out which modifier keys were pressed, and set up the // listAdjustment parameter to reflect what to do with the selected points. if (event.isModifierShift() || event.isModifierControl() ) { if ( event.isModifierShift() ) { if ( event.isModifierControl() ) { // both shift and control pressed, merge new selections listAdjustment = MGlobal::kAddToList; } else { // shift only, xor new selections with previous ones listAdjustment = MGlobal::kXORWithList; } } else if ( event.isModifierControl() ) { // control only, remove new selections from the previous list listAdjustment = MGlobal::kRemoveFromList; } } else { listAdjustment = MGlobal::kReplaceList; } // Extract the event information // event.getPosition( start_x, start_y ); // Enable OpenGL drawing on viewport view = M3dView::active3dView(); view.beginGL(); #ifdef USE_SOFTWARE_OVERLAYS p_last_x = start_x; p_last_y = start_y; fsDrawn = false; #else // If HW overlays supported then initialize the overlay plane for drawing. view.beginOverlayDrawing(); #endif return MS::kSuccess; }
MStatus moveContext::doPress( MEvent & event ) { MStatus stat = MPxSelectionContext::doPress( event ); MSpace::Space spc = MSpace::kWorld; // If we are not in selecting mode (i.e. an object has been selected) // then set up for the translation. // if ( !isSelecting() ) { event.getPosition( startPos_x, startPos_y ); view = M3dView::active3dView(); MDagPath camera; stat = view.getCamera( camera ); if ( stat != MS::kSuccess ) { cerr << "Error: M3dView::getCamera" << endl; return stat; } MFnCamera fnCamera( camera ); MVector upDir = fnCamera.upDirection( spc ); MVector rightDir = fnCamera.rightDirection( spc ); // Determine the camera used in the current view // if ( fnCamera.isOrtho() ) { if ( upDir.isEquivalent(MVector::zNegAxis,kVectorEpsilon) ) { currWin = TOP; } else if ( rightDir.isEquivalent(MVector::xAxis,kVectorEpsilon) ) { currWin = FRONT; } else { currWin = SIDE; } } else { currWin = PERSP; } // Create an instance of the move tool command. // cmd = (moveCmd*)newToolCommand(); cmd->setVector( 0.0, 0.0, 0.0 ); } return stat; }
MStatus grabUVContext::doPtrMoved( MEvent & event, MHWRender::MUIDrawManager& drawMgr, const MHWRender::MFrameContext& context) { MPxTexContext::doPtrMoved(event, drawMgr, context); double portW, portH; portSize(portW, portH); short x, y; event.getPosition( x, y ); y = short(portH) - y; fCurrentScreenPoint = MPoint( x, y ); fLastScreenPoint = MPoint( x, y ); fBrushCenterScreenPoint = MPoint( x, y ); return MS::kSuccess; }
MStatus moveContext::doRelease( MEvent & event ) { MStatus stat = MPxSelectionContext::doRelease( event ); if ( !isSelecting() ) { 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 && abs(startPos_y - endPos_y) < 2 ) { delete cmd; view.refresh( true ); } else { stat = cmd->finalize(); view.refresh( true ); } } return stat; }
MStatus lassoTool::doPress( MEvent & event ) // Set up for overlay drawing, and remember our starting point { // Figure out which modifier keys were pressed, and set up the // listAdjustment parameter to reflect what to do with the selected points. if (event.isModifierShift() || event.isModifierControl() ) { if ( event.isModifierShift() ) { if ( event.isModifierControl() ) { // both shift and control pressed, merge new selections listAdjustment = MGlobal::kAddToList; } else { // shift only, xor new selections with previous ones listAdjustment = MGlobal::kXORWithList; } } else if ( event.isModifierControl() ) { // control only, remove new selections from the previous list listAdjustment = MGlobal::kRemoveFromList; } } else { listAdjustment = MGlobal::kReplaceList; } // Get the active 3D view. // view = M3dView::active3dView(); // Create an array to hold the lasso points. Assume no mem failures maxSize = initialSize; lasso = (coord*) malloc (sizeof(coord) * maxSize); coord start; event.getPosition( start.h, start.v ); num_points = 1; lasso[0] = min = max = start; firstDraw = true; return MS::kSuccess; }
void marqueeContext::doReleaseCommon( MEvent & event ) { MSelectionList incomingList, marqueeList; // Get the end position of the marquee event.getPosition( last_x, last_y ); // Save the state of the current selections. The "selectFromSceen" // below will alter the active list, and we have to be able to put // it back. MGlobal::getActiveSelectionList(incomingList); // If we have a zero dimension box, just do a point pick // if ( abs(start_x - last_x) < 2 && abs(start_y - last_y) < 2 ) { // This will check to see if the active view is in wireframe or not. MGlobal::SelectionMethod selectionMethod = MGlobal::selectionMethod(); MGlobal::selectFromScreen( start_x, start_y, MGlobal::kReplaceList, selectionMethod ); } else { // The Maya select tool goes to wireframe select when doing a marquee, so // we will copy that behaviour. // Select all the objects or components within the marquee. MGlobal::selectFromScreen( start_x, start_y, last_x, last_y, MGlobal::kReplaceList, MGlobal::kWireframeSelectMethod ); } // Get the list of selected items MGlobal::getActiveSelectionList(marqueeList); // Restore the active selection list to what it was before // the "selectFromScreen" MGlobal::setActiveSelectionList(incomingList, MGlobal::kReplaceList); // Update the selection list as indicated by the modifier keys. MGlobal::selectCommand(marqueeList, listAdjustment); }
MStatus lassoTool::doDrag( MEvent & event ) // Add to the growing lasso { view.beginXorDrawing(true, true, 1.0f, M3dView::kStippleDashed); if (!firstDraw) { // Redraw the old lasso to clear it. draw_lasso(); } else { firstDraw = false; } coord currentPos; event.getPosition( currentPos.h, currentPos.v ); append_lasso( currentPos.h, currentPos.v ); // Draw the new lasso. draw_lasso(); view.endXorDrawing(); return MS::kSuccess; }
MStatus marqueeContext::doDrag ( MEvent & event, MHWRender::MUIDrawManager& drawMgr, const MHWRender::MFrameContext& context) { // Get the marquee's new end position. event.getPosition( last_x, last_y ); // Draw the marquee at its new position. drawMgr.beginDrawable(); drawMgr.setColor( MColor(1.0f, 1.0f, 0.0f) ); drawMgr.line2d( MPoint( start_x, start_y), MPoint(last_x, start_y) ); drawMgr.line2d( MPoint( last_x, start_y), MPoint(last_x, last_y) ); drawMgr.line2d( MPoint( last_x, last_y), MPoint(start_x, last_y) ); drawMgr.line2d( MPoint( start_x, last_y), MPoint(start_x, start_y) ); double len = (last_y - start_y) * (last_y - start_y) + (last_x - start_x) * (last_x - start_x) * 0.01; drawMgr.line(MPoint(0,0,0), MPoint(len, len, len)); drawMgr.endDrawable(); return MS::kSuccess; }
MStatus SelectRingContext1::doRelease( MEvent &event ) { // Get the mouse release position event.getPosition( releaseX, releaseY ); // Didn't select a single point if( abs(pressX - releaseX) > 1 || abs(pressY - releaseY) > 1 ) { MGlobal::displayWarning( "Click on a single edge" ); return MS::kFailure; } // Set the selection surface area int halfClickBoxSize = clickBoxSize / 2; pressX -= halfClickBoxSize; pressY -= halfClickBoxSize; releaseX = pressX + clickBoxSize; releaseY = pressY + clickBoxSize; /* // Record previous selection state prevSelMode = MGlobal::selectionMode(); prevCompMask = MGlobal::componentSelectionMask(); */ // Get the current selection MSelectionList curSel; MGlobal::getActiveSelectionList( curSel ); //MGlobal::displayInfo( MString("Dim: ") + start_x + " " + start_y + " " + last_x + " " + last_y ); // Change to object selection mode MGlobal::setSelectionMode( MGlobal::kSelectObjectMode ); MGlobal::setComponentSelectionMask( MSelectionMask( MSelectionMask::kSelectObjectsMask ) ); // Select the object under the selection area MGlobal::selectFromScreen( pressX, pressY, releaseX, releaseY, MGlobal::kReplaceList); MGlobal::executeCommand( "hilite" ); // Change selection mode to mesh edges MGlobal::setSelectionMode( MGlobal::kSelectComponentMode ); MGlobal::setComponentSelectionMask( MSelectionMask( MSelectionMask::kSelectMeshEdges ) ); // Select the edges MGlobal::selectFromScreen( pressX, pressY, releaseX, releaseY, MGlobal::kReplaceList ); // Get the list of selected edges MSelectionList origEdgesSel; MGlobal::getActiveSelectionList( origEdgesSel ); MSelectionList newEdgesSel; MDagPath dagPath; MObject component; // Only use the first edge in the selection MItSelectionList selIter( origEdgesSel, MFn::kMeshEdgeComponent ); if( !selIter.isDone() ) { selIter.getDagPath( dagPath, component ); MIntArray faces; MItMeshEdge edgeIter( dagPath, component ); MIntArray edgesVisited, facesVisited; int edgeIndex, faceIndex; int prevIndex; unsigned int i; bool finished = false; while( !finished ) { edgeIndex = edgeIter.index(); edgesVisited.append( edgeIndex ); // Create an edge component the current edge MFnSingleIndexedComponent indexedCompFn; MObject newComponent = indexedCompFn.create( MFn::kMeshEdgeComponent ); indexedCompFn.addElement( edgeIndex ); newEdgesSel.add( dagPath, newComponent ); //MGlobal::displayInfo( MString("ADDING: ") + edgeIter.index() ); edgeIter.getConnectedFaces( faces ); faceIndex = faces[0]; if( faces.length() > 1 ) { // Select the face that hasn't already been visited for( i=0; i < facesVisited.length(); i++ ) { if( faceIndex == facesVisited[i] ) { faceIndex = faces[1]; break; } } } //MGlobal::displayInfo( MString("FACE: ") + faceIndex ); facesVisited.append( faceIndex ); MItMeshPolygon polyIter( dagPath ); polyIter.setIndex( faceIndex, prevIndex ); //MGlobal::displayInfo( MString( "faces: " ) + faces[0] + " " + faces[1] ); MIntArray edges; polyIter.getEdges( edges ); // Determine the face-relative index of the current // edge unsigned int edgeFaceIndex = 0; for( i=0; i < edges.length(); i++ ) { if( edges[i] == edgeIter.index() ) { edgeFaceIndex = i; break; } } // Determine the edge that is opposite the current edge edgeIndex = edges[ (edgeFaceIndex + (edges.length() / 2) ) % edges.length() ]; //int index = edgeIter.index(); //MGlobal::displayInfo( MString( "sel edge index: " ) + index + " next edge: " + edgeIndex ); // Set the current edge to the opposite edge edgeIter.setIndex( edgeIndex, prevIndex ); // Determine if the edge has already been visited for( i=0; i < edgesVisited.length(); i++ ) { if( edgeIndex == edgesVisited[i] ) { finished = true; break; } } } } // Set the active selection to the one previous to edge loop selection MGlobal::setActiveSelectionList( curSel, MGlobal::kReplaceList); // Update this selection based on the list adjustment setting MGlobal::selectCommand( newEdgesSel, listAdjust ); return MS::kSuccess; }
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 marqueeContext::doDrag( MEvent & event ) // // Drag out the marquee (using OpenGL) // { event.getPosition( last_x, last_y ); #ifdef USE_SOFTWARE_OVERLAYS GLboolean depthTest[1]; GLboolean colorLogicOp[1]; GLboolean lineStipple[1]; // Save the state of these 3 attribtes and restore them later. glGetBooleanv (GL_DEPTH_TEST, depthTest); glGetBooleanv (GL_COLOR_LOGIC_OP, colorLogicOp); glGetBooleanv (GL_LINE_STIPPLE, lineStipple); #endif // Turn Line stippling on. glLineStipple( 1, 0x5555 ); glLineWidth( 1.0 ); glEnable( GL_LINE_STIPPLE ); // Save the state of the matrix on stack glMatrixMode (GL_MODELVIEW); glPushMatrix(); // Setup the Orthographic projection Matrix. glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluOrtho2D( 0.0, (GLdouble) view.portWidth(), 0.0, (GLdouble) view.portHeight() ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef(0.375, 0.375, 0.0); // Set the draw color glIndexi (2); // If we are using software overlays then we need to draw the marquee // in XOR mode #ifdef USE_SOFTWARE_OVERLAYS glDisable (GL_DEPTH_TEST); // Enable XOR mode. glEnable(GL_COLOR_LOGIC_OP); glLogicOp (GL_XOR); // We erase the previously drawn rubber band on the screen by // redrawing it in XOR OpenGL mode. if (fsDrawn) { glBegin( GL_LINE_LOOP ); glVertex2i( start_x, start_y ); glVertex2i( p_last_x, start_y ); glVertex2i( p_last_x, p_last_y ); glVertex2i( start_x, p_last_y ); glEnd(); } fsDrawn = true; #else // If HW overlays enabled then we will clear the overlay plane // so that the previously drawn marquee does not appear on the screen // anymore view.clearOverlayPlane(); #endif // Draw the rectangular marquee // glBegin( GL_LINE_LOOP ); glVertex2i( start_x, start_y ); glVertex2i( last_x, start_y ); glVertex2i( last_x, last_y ); glVertex2i( start_x, last_y ); glEnd(); #ifdef _WIN32 SwapBuffers( view.deviceContext() ); #elif defined (OSMac_) ::aglSwapBuffers(view.display()); #else glXSwapBuffers( view.display(), view.window() ); #endif // Restore the state of the matrix from stack glMatrixMode( GL_MODELVIEW ); glPopMatrix(); #ifdef USE_SOFTWARE_OVERLAYS // Store the current x and y coordinates such that in the next iteration // we can erase this marquee by redrawing it in XOR mode. p_last_x = last_x; p_last_y = last_y; // Restore the previous state of these attributes if (colorLogicOp[0]) glEnable (GL_COLOR_LOGIC_OP); else glDisable (GL_COLOR_LOGIC_OP); if (depthTest[0]) glEnable (GL_DEPTH_TEST); else glDisable (GL_DEPTH_TEST); if (lineStipple[0]) glEnable( GL_LINE_STIPPLE ); else glDisable( GL_LINE_STIPPLE ); #endif return MS::kSuccess; }
MStatus marqueeContext::doRelease( MEvent & event ) // // Selects objects within the marquee box. { MSelectionList incomingList, marqueeList; // Clear the marquee when you release the mouse button #ifdef USE_SOFTWARE_OVERLAYS GLboolean depthTest[1]; GLboolean colorLogicOp[1]; GLboolean lineStipple[1]; event.getPosition( last_x, last_y ); // Save the state of these 3 attribtes and restore them later. glGetBooleanv (GL_DEPTH_TEST, depthTest); glGetBooleanv (GL_COLOR_LOGIC_OP, colorLogicOp); glGetBooleanv (GL_LINE_STIPPLE, lineStipple); // Turn Line stippling on. glLineStipple( 1, 0x5555 ); glLineWidth( 1.0 ); glEnable( GL_LINE_STIPPLE ); // Disable GL_DEPTH_TEST glDisable (GL_DEPTH_TEST); // Enable XOR mode. glEnable(GL_COLOR_LOGIC_OP); glLogicOp (GL_INVERT); // Save the current Matrix onto the stack glMatrixMode (GL_MODELVIEW); glPushMatrix(); // Setup the Orthographic projection Matrix. glMatrixMode( GL_PROJECTION ); glLoadIdentity(); gluOrtho2D( 0.0, (GLdouble) view.portWidth(), 0.0, (GLdouble) view.portHeight() ); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glTranslatef(0.375, 0.375, 0.0); // Set the draw color glIndexi (2); // Redraw the marquee so that it will be cleared from the screen // when the mouse is released. glBegin( GL_LINE_LOOP ); glVertex2i( start_x, start_y ); glVertex2i( p_last_x, start_y ); glVertex2i( p_last_x, p_last_y ); glVertex2i( start_x, p_last_y ); glEnd(); #ifndef _WIN32 glXSwapBuffers( view.display(), view.window() ); #else SwapBuffers( view.deviceContext() ); #endif // Restore saved Matrix from stack glMatrixMode( GL_MODELVIEW ); glPopMatrix(); glDisable(GL_COLOR_LOGIC_OP); // Restore the previous state of these attributes if (colorLogicOp[0]) glEnable (GL_COLOR_LOGIC_OP); else glDisable (GL_COLOR_LOGIC_OP); if (depthTest[0]) glEnable (GL_DEPTH_TEST); else glDisable (GL_DEPTH_TEST); if (lineStipple[0]) glEnable( GL_LINE_STIPPLE ); else glDisable( GL_LINE_STIPPLE ); #else // If HW overlays enabled, then clear the overlay plane // such that the marquee is no longer drawn on screen. view.clearOverlayPlane(); view.endOverlayDrawing(); #endif view.endGL(); // Get the end position of the marquee event.getPosition( last_x, last_y ); // Save the state of the current selections. The "selectFromSceen" // below will alter the active list, and we have to be able to put // it back. MGlobal::getActiveSelectionList(incomingList); // If we have a zero dimension box, just do a point pick // if ( abs(start_x - last_x) < 2 && abs(start_y - last_y) < 2 ) { MGlobal::selectFromScreen( start_x, start_y, MGlobal::kReplaceList ); } else { // Select all the objects or components within the marquee. MGlobal::selectFromScreen( start_x, start_y, last_x, last_y, MGlobal::kReplaceList ); } // Get the list of selected items MGlobal::getActiveSelectionList(marqueeList); // Restore the active selection list to what it was before // the "selectFromScreen" MGlobal::setActiveSelectionList(incomingList, MGlobal::kReplaceList); // Update the selection list as indicated by the modifier keys. MGlobal::selectCommand(marqueeList, listAdjustment); return MS::kSuccess; }
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 SelectRingContext2::doRelease( MEvent &event ) { // Get the mouse release position event.getPosition( releaseX, releaseY ); // Didn't select a single point if( abs(pressX - releaseX) > 1 || abs(pressY - releaseY) > 1 ) { MGlobal::displayWarning( "Click on a single edge" ); return MS::kFailure; } // Set the selection surface area int halfClickBoxSize = clickBoxSize / 2; pressX -= halfClickBoxSize; pressY -= halfClickBoxSize; releaseX = pressX + clickBoxSize; releaseY = pressY + clickBoxSize; // Get the current selection MSelectionList curSel; MGlobal::getActiveSelectionList( curSel ); //MGlobal::displayInfo( MString("Dim: ") + start_x + " " + start_y + " " + last_x + " " + last_y ); // Change to object selection mode MGlobal::setSelectionMode( MGlobal::kSelectObjectMode ); MGlobal::setComponentSelectionMask( MSelectionMask( MSelectionMask::kSelectObjectsMask ) ); // Select the object under the selection area MGlobal::selectFromScreen( pressX, pressY, releaseX, releaseY, MGlobal::kReplaceList); MGlobal::executeCommand( "hilite" ); // Change selection mode to mesh edges MGlobal::setSelectionMode( MGlobal::kSelectComponentMode ); MGlobal::setComponentSelectionMask( MSelectionMask( MSelectionMask::kSelectMeshEdges ) ); // Select the edges MGlobal::selectFromScreen( pressX, pressY, releaseX, releaseY, MGlobal::kReplaceList ); // Get the list of selected edges MSelectionList origEdgesSel; MGlobal::getActiveSelectionList( origEdgesSel ); // Only use the first edge in the selection MItSelectionList selIter( origEdgesSel, MFn::kMeshEdgeComponent ); if( !selIter.isDone() ) { MDagPath dagPath; MObject component; selIter.getDagPath( dagPath, component ); SelectRingToolCmd2 &cmd = *(SelectRingToolCmd2 *) newToolCommand(); cmd.setCurrentSelection( curSel ); cmd.setSelectedEdgeObject( dagPath ); cmd.setSelectedEdgeComponent( component ); cmd.setListAdjust( listAdjust ); cmd.setSelEdges( selEdges ); cmd.setSelFaces( selFaces ); cmd.setSelVertices( selVertices ); cmd.setSelType( SelectRingToolCmd2::SelType(selType) ); cmd.redoIt(); cmd.finalize(); } 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; }