void BaseShapeUI::getDrawRequests( const MDrawInfo & info, bool objectAndActiveOnly, MDrawRequestQueue & requests ) {
MStatus status;
MDrawData data;
BaseShape *shape = (BaseShape *) surfaceShape();
MDrawRequest request = info.getPrototype(*this);
M3dView view = info.view();
getDrawData(shape, data);
request.setDrawData(data);
MDagPath path = request.multiPath();
MMaterial material = MPxSurfaceShapeUI::material(path);
if (!(status = material.evaluateMaterial(view, path)))
status.perror("MMaterial::evaluateMaterial");
if (!(status = material.evaluateDiffuse()))
status.perror("MMaterial::evaluateDiffuse");
request.setMaterial(material);
request.setToken(info.displayStyle());
requests.add(request);
}
/* override */
bool apiSimpleShapeUI::select( MSelectInfo &selectInfo, MSelectionList &selectionList,
MPointArray &worldSpaceSelectPts ) const
//
// Description:
//
// Main selection routine
//
// Arguments:
//
// selectInfo - the selection state information
// selectionList - the list of selected items to add to
// worldSpaceSelectPts -
//
{
bool selected = false;
bool componentSelected = false;
bool hilited = false;
hilited = (selectInfo.displayStatus() == M3dView::kHilite);
if ( hilited ) {
componentSelected = selectVertices( selectInfo, selectionList, worldSpaceSelectPts );
selected = selected || componentSelected;
}
if ( !selected )
{
// NOTE: If the geometry has an intersect routine it should
// be called here with the selection ray to determine if the
// the object was selected.
selected = true;
MSelectionMask priorityMask( MSelectionMask::kSelectNurbsSurfaces );
MSelectionList item;
item.add( selectInfo.selectPath() );
MPoint xformedPt;
if ( selectInfo.singleSelection() ) {
MPoint center = surfaceShape()->boundingBox().center();
xformedPt = center;
xformedPt *= selectInfo.selectPath().inclusiveMatrix();
}
selectInfo.addSelection( item, xformedPt, selectionList,
worldSpaceSelectPts, priorityMask, false );
}
return selected;
}
void BaseShapeUI::draw( const MDrawRequest & request, M3dView & view ) const {
if (s_drawData.failure)
return;
MStatus status;
view.beginGL();
if (!s_drawData.initialized)
initializeDraw();
BaseShape *shape = (BaseShape *) surfaceShape();
Model::Base base(MFnDagNode(shape->thisMObject()).parent(0, &status));
if (!status) {
status.perror("MFnDagNode::parent");
return;
}
//MDagPath path = request.multiPath();
MMaterial material = request.material();
MColor color, borderColor;
if (!(status = material.getDiffuse(color))) {
status.perror("MMaterial::getDiffuse");
return;
}
bool wireframe = (M3dView::DisplayStyle) request.token() == M3dView::kWireFrame;
if (wireframe) {
glPushAttrib(GL_POLYGON_BIT);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
glUseProgram(s_drawData.program);
switch (request.displayStatus())
{
case M3dView::kLead :
borderColor = view.colorAtIndex( LEAD_COLOR);
//glUniform1f(s_drawData.border_uniform, 1.0f);
s_drawData.updateBorderUniform(1.0f);
//glUniform3f(s_drawData.borderColor_uniform, borderColor.r, borderColor.g, borderColor.b);
s_drawData.updateBorderColorUniform(borderColor.r, borderColor.g, borderColor.b);
break;
case M3dView::kActive :
borderColor = view.colorAtIndex( ACTIVE_COLOR);
//glUniform1f(s_drawData.border_uniform, 1.0f);
s_drawData.updateBorderUniform(1.0f);
//glUniform3f(s_drawData.borderColor_uniform, borderColor.r, borderColor.g, borderColor.b);
s_drawData.updateBorderColorUniform(borderColor.r, borderColor.g, borderColor.b);
break;
case M3dView::kActiveAffected :
borderColor = view.colorAtIndex( ACTIVE_AFFECTED_COLOR);
//glUniform1f(s_drawData.border_uniform, 0.0f);
s_drawData.updateBorderUniform(0.0f);
break;
case M3dView::kDormant :
borderColor = view.colorAtIndex( DORMANT_COLOR, M3dView::kDormantColors);
//glUniform1f(s_drawData.border_uniform, 0.0f);
s_drawData.updateBorderUniform(0.0f);
break;
case M3dView::kHilite :
borderColor = view.colorAtIndex( HILITE_COLOR);
//glUniform1f(s_drawData.border_uniform, 1.0f);
s_drawData.updateBorderUniform(1.0f);
//glUniform3f(s_drawData.borderColor_uniform, borderColor.r, borderColor.g, borderColor.b);
s_drawData.updateBorderColorUniform(borderColor.r, borderColor.g, borderColor.b);
break;
}
//glUniform3f(s_drawData.color_uniform, color.r, color.g, color.b);
s_drawData.updateColorUniform(color.r, color.g, color.b);
glCallList(s_drawData.display_list);
if (wireframe)
glPopAttrib();
view.endGL();
}
/* override */
void apiSimpleShapeUI::getDrawRequests( const MDrawInfo & info,
bool objectAndActiveOnly,
MDrawRequestQueue & queue )
//
// Description:
//
// Add draw requests to the draw queue
//
// Arguments:
//
// info - current drawing state
// objectsAndActiveOnly - no components if true
// queue - queue of draw requests to add to
//
{
// Get the data necessary to draw the shape
//
MDrawData data;
apiSimpleShape* shape = (apiSimpleShape*) surfaceShape();
MVectorArray* geomPtr = shape->getControlPoints();
// This call creates a prototype draw request that we can fill
// in and then add to the draw queue.
//
MDrawRequest request = info.getPrototype( *this );
// Stuff our data into the draw request, it'll be used when the drawing
// actually happens
getDrawData( geomPtr, data );
request.setDrawData( data );
// Decode the draw info and determine what needs to be drawn
//
M3dView::DisplayStyle appearance = info.displayStyle();
M3dView::DisplayStatus displayStatus = info.displayStatus();
switch ( appearance )
{
case M3dView::kWireFrame :
{
request.setToken( kDrawWireframe );
M3dView::ColorTable activeColorTable = M3dView::kActiveColors;
M3dView::ColorTable dormantColorTable = M3dView::kDormantColors;
switch ( displayStatus )
{
case M3dView::kLead :
request.setColor( LEAD_COLOR, activeColorTable );
break;
case M3dView::kActive :
request.setColor( ACTIVE_COLOR, activeColorTable );
break;
case M3dView::kActiveAffected :
request.setColor( ACTIVE_AFFECTED_COLOR, activeColorTable );
break;
case M3dView::kDormant :
request.setColor( DORMANT_COLOR, dormantColorTable );
break;
case M3dView::kHilite :
request.setColor( HILITE_COLOR, activeColorTable );
break;
default:
break;
}
queue.add( request );
break;
}
case M3dView::kGouraudShaded :
{
// Create the smooth shaded draw request
//
request.setToken( kDrawSmoothShaded );
// Need to get the material info
//
MDagPath path = info.multiPath(); // path to your dag object
M3dView view = info.view();; // view to draw to
MMaterial material = MPxSurfaceShapeUI::material( path );
// Evaluate the material and if necessary, the texture.
//
if ( ! material.evaluateMaterial( view, path ) ) {
cerr << "Couldnt evaluate\n";
}
bool drawTexture = true;
if ( drawTexture && material.materialIsTextured() ) {
material.evaluateTexture( data );
}
request.setMaterial( material );
// request.setDisplayStyle( appearance );
bool materialTransparent = false;
material.getHasTransparency( materialTransparent );
if ( materialTransparent ) {
request.setIsTransparent( true );
}
queue.add( request );
// create a draw request for wireframe on shaded if
// necessary.
//
if ( (displayStatus == M3dView::kActive) ||
(displayStatus == M3dView::kLead) ||
(displayStatus == M3dView::kHilite) )
{
MDrawRequest wireRequest = info.getPrototype( *this );
wireRequest.setDrawData( data );
wireRequest.setToken( kDrawWireframeOnShaded );
wireRequest.setDisplayStyle( M3dView::kWireFrame );
M3dView::ColorTable activeColorTable = M3dView::kActiveColors;
switch ( displayStatus )
{
case M3dView::kLead :
wireRequest.setColor( LEAD_COLOR, activeColorTable );
break;
case M3dView::kActive :
wireRequest.setColor( ACTIVE_COLOR, activeColorTable );
break;
case M3dView::kHilite :
wireRequest.setColor( HILITE_COLOR, activeColorTable );
break;
default :
break;
}
queue.add( wireRequest );
}
break;
}
case M3dView::kFlatShaded :
request.setToken( kDrawFlatShaded );
break;
default:
break;
}
// Add draw requests for components
//
if ( !objectAndActiveOnly ) {
// Inactive components
//
if ( (appearance == M3dView::kPoints) ||
(displayStatus == M3dView::kHilite) )
{
MDrawRequest vertexRequest = info.getPrototype( *this );
vertexRequest.setDrawData( data );
vertexRequest.setToken( kDrawVertices );
vertexRequest.setColor( DORMANT_VERTEX_COLOR,
M3dView::kActiveColors );
queue.add( vertexRequest );
}
// Active components
//
if ( surfaceShape()->hasActiveComponents() ) {
MDrawRequest activeVertexRequest = info.getPrototype( *this );
activeVertexRequest.setDrawData( data );
activeVertexRequest.setToken( kDrawVertices );
activeVertexRequest.setColor( ACTIVE_VERTEX_COLOR,
M3dView::kActiveColors );
MObjectArray clist = surfaceShape()->activeComponents();
MObject vertexComponent = clist[0]; // Should filter list
activeVertexRequest.setComponent( vertexComponent );
queue.add( activeVertexRequest );
}
}
}
bool apiSimpleShapeUI::selectVertices( MSelectInfo &selectInfo,
MSelectionList &selectionList,
MPointArray &worldSpaceSelectPts ) const
//
// Description:
//
// Vertex selection.
//
// Arguments:
//
// selectInfo - the selection state information
// selectionList - the list of selected items to add to
// worldSpaceSelectPts -
//
{
bool selected = false;
M3dView view = selectInfo.view();
MPoint xformedPoint;
MPoint currentPoint;
MPoint selectionPoint;
double z,previousZ = 0.0;
int closestPointVertexIndex = -1;
const MDagPath & path = selectInfo.multiPath();
// Create a component that will store the selected vertices
//
MFnSingleIndexedComponent fnComponent;
MObject surfaceComponent = fnComponent.create( MFn::kMeshVertComponent );
int vertexIndex;
// if the user did a single mouse click and we find > 1 selection
// we will use the alignmentMatrix to find out which is the closest
//
MMatrix alignmentMatrix;
MPoint singlePoint;
bool singleSelection = selectInfo.singleSelection();
if( singleSelection ) {
alignmentMatrix = selectInfo.getAlignmentMatrix();
}
// Get the geometry information
//
apiSimpleShape* shape = (apiSimpleShape*) surfaceShape();
MVectorArray* geomPtr = shape->getControlPoints();
MVectorArray& geom = *geomPtr;
// Loop through all vertices of the mesh and
// see if they lie withing the selection area
//
int numVertices = geom.length();
for ( vertexIndex=0; vertexIndex<numVertices; vertexIndex++ )
{
const MVector& point = geom[ vertexIndex ];
// Sets OpenGL's render mode to select and stores
// selected items in a pick buffer
//
view.beginSelect();
glBegin( GL_POINTS );
glVertex3f( (float)point[0],
(float)point[1],
(float)point[2] );
glEnd();
if ( view.endSelect() > 0 ) // Hit count > 0
{
selected = true;
if ( singleSelection ) {
xformedPoint = currentPoint;
xformedPoint.homogenize();
xformedPoint*= alignmentMatrix;
z = xformedPoint.z;
if ( closestPointVertexIndex < 0 || z > previousZ ) {
closestPointVertexIndex = vertexIndex;
singlePoint = currentPoint;
previousZ = z;
}
} else {
// multiple selection, store all elements
//
fnComponent.addElement( vertexIndex );
}
}
}
// If single selection, insert the closest point into the array
//
if ( selected && selectInfo.singleSelection() ) {
fnComponent.addElement(closestPointVertexIndex);
// need to get world space position for this vertex
//
selectionPoint = singlePoint;
selectionPoint *= path.inclusiveMatrix();
}
// Add the selected component to the selection list
//
if ( selected ) {
MSelectionList selectionItem;
selectionItem.add( path, surfaceComponent );
MSelectionMask mask( MSelectionMask::kSelectComponentsMask );
selectInfo.addSelection(
selectionItem, selectionPoint,
selectionList, worldSpaceSelectPts,
mask, true );
}
return selected;
}
