public void getDrawRequestsShaded(MDrawRequest request,
MDrawInfo info,
MDrawRequestQueue queue,
MDrawData data)
{
// 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 = base.material(path);
M3dView.DisplayStatus displayStatus = info.displayStatus;
// Evaluate the material and if necessary, the texture.
//
material.evaluateMaterial(view, path);
bool drawTexture = true;
if (drawTexture && material.materialIsTextured)
{
material.evaluateTexture(data);
}
request.material = material;
bool materialTransparent = false;
material.getHasTransparency(ref materialTransparent);
if (materialTransparent)
{
request.isTransparent = true;
}
// create a draw request for wireframe on shaded if
// necessary.
//
if ((displayStatus == M3dView.DisplayStatus.kActive) ||
(displayStatus == M3dView.DisplayStatus.kLead) ||
(displayStatus == M3dView.DisplayStatus.kHilite))
{
MDrawRequest wireRequest = info.getPrototype(this);
wireRequest.setDrawData(data);
getDrawRequestsWireframe(wireRequest, info);
wireRequest.token = (int)DrawShapeStyle.kDrawWireframeOnShaded;
wireRequest.displayStyle = M3dView.DisplayStyle.kWireFrame;
queue.add(wireRequest);
}
}
public override void draw(MDrawRequest request, M3dView view)
//
// From the given draw request, get the draw data and determine
// which quadric to draw and with what values.
//
{
MDrawData data = request.drawData();
quadricGeom geom = data.geometry() as quadricGeom;
DrawShapeStyle token = (DrawShapeStyle)request.token;
bool drawTexture = false;
view.beginGL();
if ((token == DrawShapeStyle.kDrawSmoothShaded) || (token == DrawShapeStyle.kDrawFlatShaded))
{
OpenGL.glEnable((uint)OpenGL.GL_POLYGON_OFFSET_FILL);
// Set up the material
//
MMaterial material = request.material;
material.setMaterial(request.multiPath, request.isTransparent);
// Enable texturing
//
drawTexture = material.materialIsTextured;
if (drawTexture)
{
OpenGL.glEnable((uint)OpenGL.GL_TEXTURE_2D);
}
// Apply the texture to the current view
//
if (drawTexture)
{
material.applyTexture(view, data);
}
}
IntPtr qobj = GLUFunctionInvoker.gluNewQuadric();
switch (token)
{
case DrawShapeStyle.kDrawWireframe:
case DrawShapeStyle.kDrawWireframeOnShaded:
GLUFunctionInvoker.gluQuadricDrawStyle(qobj, GLU_LINE);
break;
case DrawShapeStyle.kDrawSmoothShaded:
GLUFunctionInvoker.gluQuadricNormals(qobj, GLU_SMOOTH);
GLUFunctionInvoker.gluQuadricTexture(qobj, GLtrue);
GLUFunctionInvoker.gluQuadricDrawStyle(qobj, GLU_FILL);
break;
case DrawShapeStyle.kDrawFlatShaded:
GLUFunctionInvoker.gluQuadricNormals(qobj, GLU_FLAT);
GLUFunctionInvoker.gluQuadricTexture(qobj, GLtrue);
GLUFunctionInvoker.gluQuadricDrawStyle(qobj, GLU_FILL);
break;
}
switch (geom.shapeType)
{
case (short)DrawShapeType.kDrawCylinder:
GLUFunctionInvoker.gluCylinder(qobj, geom.radius1, geom.radius2, geom.height,
geom.slices, geom.stacks);
break;
case (short)DrawShapeType.kDrawDisk:
GLUFunctionInvoker.gluDisk(qobj, geom.radius1, geom.radius2, geom.slices, geom.loops);
break;
case (short)DrawShapeType.kDrawPartialDisk:
GLUFunctionInvoker.gluPartialDisk(qobj, geom.radius1, geom.radius2, geom.slices,
geom.loops, geom.startAngle, geom.sweepAngle);
break;
case (short)DrawShapeType.kDrawSphere:
default:
GLUFunctionInvoker.gluSphere(qobj, geom.radius1, geom.slices, geom.stacks);
break;
}
// Turn off texture mode
//
if (drawTexture)
{
OpenGL.glDisable((uint)OpenGL.GL_TEXTURE_2D);
}
view.endGL();
}
//
// 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
//
/////////////////////////////////////////////////////////////////////
//
// Overrides
//
/////////////////////////////////////////////////////////////////////
public override void getDrawRequests( MDrawInfo info,
bool objectAndActiveOnly,
MDrawRequestQueue queue)
{
// Get the data necessary to draw the shape
//
MDrawData data = new MDrawData();
apiMesh meshNode = (apiMesh)surfaceShape;
apiMeshGeom geom = meshNode.meshGeom();
if ( (null == geom) || (0 == geom.faceCount) )
{
MGlobal.displayInfo("NO DrawRequest for apiMesh");
return;
}
// This call creates a prototype draw request that we can fill
// in and then add to the draw queue.
//
MDrawRequest request = getDrawRequest(info); // info.getPrototype(this);
getDrawData( geom, out 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;
// Are we displaying meshes?
if ( ! info.objectDisplayStatus( M3dView.DisplayObjects.kDisplayMeshes ) )
return;
// Use this code to help speed up drawing.
// inUserInteraction() is true for any interaction with
// the viewport, including object or component TRS and camera changes.
// userChangingViewContext() is true only when the user is using view
// context tools (tumble, dolly, track, etc.)
//
if ( info.inUserInteraction || info.userChangingViewContext )
{
// User is using view context tools so
// request fast draw and get out
//
request.token = (int)DrawToken.kDrawRedPointAtCenter;
queue.add( request );
return;
}
switch ( appearance )
{
case M3dView.DisplayStyle.kWireFrame :
{
request.token = (int)DrawToken.kDrawWireframe;
int activeColorTable = (int)M3dView.ColorTable.kActiveColors;
int dormantColorTable = (int)M3dView.ColorTable.kDormantColors;
switch ( displayStatus )
{
case M3dView.DisplayStatus.kLead :
request.setColor( LEAD_COLOR, activeColorTable );
break;
case M3dView.DisplayStatus.kActive :
request.setColor( ACTIVE_COLOR, activeColorTable );
break;
case M3dView.DisplayStatus.kActiveAffected :
request.setColor( ACTIVE_AFFECTED_COLOR, activeColorTable );
break;
case M3dView.DisplayStatus.kDormant :
request.setColor( DORMANT_COLOR, dormantColorTable );
break;
case M3dView.DisplayStatus.kHilite :
request.setColor( HILITE_COLOR, activeColorTable );
break;
default:
break;
}
queue.add( request );
break;
}
case M3dView.DisplayStyle.kGouraudShaded :
{
// Create the smooth shaded draw request
//
request.token = (int)DrawToken.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 = base.material( path );
// If the user currently has the default material enabled on the
// view then use the default material for shading.
//
if ( view.usingDefaultMaterial ) {
material = MMaterial.defaultMaterial;
}
// Evaluate the material and if necessary, the texture.
//
material.evaluateMaterial( view, path );
bool drawTexture = true;
if ( drawTexture && material.materialIsTextured ) {
material.evaluateTexture( data );
}
request.material = material;
// request.setDisplayStyle( appearance );
bool materialTransparent = false;
material.getHasTransparency( ref materialTransparent );
if ( materialTransparent ) {
request.isTransparent = true;
}
queue.add( request );
// create a draw request for wireframe on shaded if
// necessary.
//
if ( (displayStatus == M3dView.DisplayStatus.kActive) ||
(displayStatus == M3dView.DisplayStatus.kLead) ||
(displayStatus == M3dView.DisplayStatus.kHilite) )
{
MDrawRequest wireRequest = getDrawRequest(info); // info.getPrototype(this);
wireRequest.setDrawData( data );
wireRequest.token = (int)DrawToken.kDrawWireframeOnShaded;
wireRequest.displayStyle = M3dView.DisplayStyle.kWireFrame;
int activeColorTable = (int)M3dView.ColorTable.kActiveColors;
switch ( displayStatus )
{
case M3dView.DisplayStatus.kLead :
wireRequest.setColor( LEAD_COLOR, activeColorTable );
break;
case M3dView.DisplayStatus.kActive :
wireRequest.setColor( ACTIVE_COLOR, activeColorTable );
break;
case M3dView.DisplayStatus.kHilite :
wireRequest.setColor( HILITE_COLOR, activeColorTable );
break;
default:
break;
}
queue.add( wireRequest );
}
break;
}
case M3dView.DisplayStyle.kFlatShaded :
request.token = (int)DrawToken.kDrawFlatShaded;
queue.add( request );
break;
case M3dView.DisplayStyle.kBoundingBox :
request.token = (int)DrawToken.kDrawBoundingBox;
queue.add( request );
break;
default:
break;
}
// Add draw requests for components
//
if ( !objectAndActiveOnly ) {
// Inactive components
//
if ( (appearance == M3dView.DisplayStyle.kPoints) ||
(displayStatus == M3dView.DisplayStatus.kHilite) )
{
MDrawRequest vertexRequest = getDrawRequest(info); // info.getPrototype(this);
vertexRequest.setDrawData( data );
vertexRequest.token = (int)DrawToken.kDrawVertices;
vertexRequest.setColor( DORMANT_VERTEX_COLOR,
(int)M3dView.ColorTable.kActiveColors );
queue.add( vertexRequest );
}
// Active components
//
if ( ((MPxSurfaceShape)surfaceShape).hasActiveComponents ) {
MDrawRequest activeVertexRequest = getDrawRequest(info); // info.getPrototype(this);
activeVertexRequest.setDrawData( data );
activeVertexRequest.token = (int)DrawToken.kDrawVertices;
activeVertexRequest.setColor( ACTIVE_VERTEX_COLOR,
(int)M3dView.ColorTable.kActiveColors);
MObjectArray clist = ((MPxSurfaceShape)surfaceShape).activeComponents;
MObject vertexComponent = clist[0]; // Should filter list
activeVertexRequest.component = vertexComponent;
queue.add( activeVertexRequest );
}
}
}
public void getDrawRequestsShaded(MDrawRequest request,
MDrawInfo info,
MDrawRequestQueue queue,
MDrawData data)
{
// 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 = base.material(path);
M3dView.DisplayStatus displayStatus = info.displayStatus;
// Evaluate the material and if necessary, the texture.
//
material.evaluateMaterial(view, path);
bool drawTexture = true;
if (drawTexture && material.materialIsTextured)
{
material.evaluateTexture(data);
}
request.material = material;
bool materialTransparent = false;
material.getHasTransparency( ref materialTransparent);
if ( materialTransparent ) {
request.isTransparent = true;
}
// create a draw request for wireframe on shaded if
// necessary.
//
if ((displayStatus == M3dView.DisplayStatus.kActive) ||
(displayStatus == M3dView.DisplayStatus.kLead) ||
(displayStatus == M3dView.DisplayStatus.kHilite))
{
MDrawRequest wireRequest = info.getPrototype(this);
wireRequest.setDrawData(data);
getDrawRequestsWireframe(wireRequest, info);
wireRequest.token = (int)DrawShapeStyle.kDrawWireframeOnShaded;
wireRequest.displayStyle = M3dView.DisplayStyle.kWireFrame;
queue.add(wireRequest);
}
}
public void drawVertices(MDrawRequest request, M3dView view)
//
// Description:
//
// Component (vertex) drawing routine
//
// Arguments:
//
// request - request to be drawn
// view - view to draw into
//
{
MDrawData data = request.drawData();
apiMeshGeom geom = (apiMeshGeom)data.geometry();
if (geom == null)
{
return;
}
view.beginGL();
// Query current state so it can be restored
//
bool lightingWasOn = OpenGL.glIsEnabled(OpenGL.GL_LIGHTING) != 0;
if (lightingWasOn)
{
OpenGL.glDisable(OpenGL.GL_LIGHTING);
}
float[] lastPointSize = new float[1];
OpenGL.glGetFloatv(OpenGL.GL_POINT_SIZE, lastPointSize);
// Set the point size of the vertices
//
OpenGL.glPointSize(POINT_SIZE);
// If there is a component specified by the draw request
// then loop over comp (using an MFnComponent class) and draw the
// active vertices, otherwise draw all vertices.
//
MObject comp = request.component;
if (!comp.isNull)
{
MFnSingleIndexedComponent fnComponent = new MFnSingleIndexedComponent(comp);
for (int i = 0; i < fnComponent.elementCount; i++)
{
int index = fnComponent.element(i);
OpenGL.glBegin(OpenGL.GL_POINTS);
MPoint vertex = geom.vertices[index];
OpenGL.glVertex3f((float)vertex[0],
(float)vertex[1],
(float)vertex[2]);
OpenGL.glEnd();
string annotation = index.ToString();
view.drawText(annotation, vertex);
}
}
else
{
int vid = 0;
for (int i = 0; i < geom.faceCount; i++)
{
OpenGL.glBegin(OpenGL.GL_POINTS);
for (int v = 0; v < geom.face_counts[i]; v++)
{
MPoint vertex = geom.vertices[geom.face_connects[vid++]];
OpenGL.glVertex3f((float)vertex[0],
(float)vertex[1],
(float)vertex[2]);
}
OpenGL.glEnd();
}
}
// Restore the state
//
if (lightingWasOn)
{
OpenGL.glEnable(OpenGL.GL_LIGHTING);
}
OpenGL.glPointSize(lastPointSize[0]);
view.endGL();
}
public void drawShaded(MDrawRequest request, M3dView view)
//
// Description:
//
// Shaded drawing routine
//
// Arguments:
//
// request - request to be drawn
// view - view to draw into
//
{
MDrawData data = request.drawData();
apiMeshGeom geom = (apiMeshGeom)data.geometry();
if (geom == null)
{
return;
}
view.beginGL();
OpenGL.glEnable(OpenGL.GL_POLYGON_OFFSET_FILL);
// Set up the material
//
MMaterial material = request.material;
material.setMaterial(request.multiPath, request.isTransparent);
// Enable texturing ...
//
// Note, Maya does not enable texturing if useDefaultMaterial is enabled.
// However, you can choose to ignore this in your draw routine.
//
bool drawTexture = material.materialIsTextured && !view.usingDefaultMaterial;
if (drawTexture)
{
OpenGL.glEnable(OpenGL.GL_TEXTURE_2D);
}
// Apply the texture to the current view
//
if (drawTexture)
{
material.applyTexture(view, data);
}
// Draw the polygons
//
int vid = 0;
uint uv_len = geom.uvcoords.uvcount();
for (int i = 0; i < geom.faceCount; i++)
{
OpenGL.glBegin(OpenGL.GL_POLYGON);
for (int v = 0; v < geom.face_counts[i]; v++)
{
MPoint vertex = geom.vertices[geom.face_connects[vid]];
MVector normal = geom.normals[geom.face_connects[vid]];
if (uv_len > 0)
{
// If we are drawing the texture, make sure the coord
// arrays are in bounds.
if (drawTexture)
{
int uvId1 = geom.uvcoords.uvId(vid);
if (uvId1 < uv_len)
{
float tu = 0.0f;
float tv = 0.0f;
geom.uvcoords.getUV(uvId1, ref tu, ref tv);
OpenGL.glTexCoord2f(tu, tv);
}
}
}
OpenGL.glNormal3f((float)normal[0], (float)normal[1], (float)normal[2]);
OpenGL.glVertex3f((float)vertex[0], (float)vertex[1], (float)vertex[2]);
vid++;
}
OpenGL.glEnd();
}
// Turn off texture mode
//
if (drawTexture)
{
OpenGL.glDisable(OpenGL.GL_TEXTURE_2D);
}
view.endGL();
}
/////////////////////////////////////////////////////////////////////
//
// Helper routines
//
/////////////////////////////////////////////////////////////////////
public void drawWireframe(MDrawRequest request, M3dView view)
//
// Description:
//
// Wireframe drawing routine
//
// Arguments:
//
// request - request to be drawn
// view - view to draw into
//
{
MDrawData data = request.drawData();
apiMeshGeom geom = (apiMeshGeom)data.geometry();
if (geom == null)
{
return;
}
int token = request.token;
bool wireFrameOnShaded = false;
if ((int)DrawToken.kDrawWireframeOnShaded == token)
{
wireFrameOnShaded = true;
}
view.beginGL();
// Query current state so it can be restored
//
bool lightingWasOn = OpenGL.glIsEnabled(OpenGL.GL_LIGHTING) != 0;
if (lightingWasOn)
{
OpenGL.glDisable(OpenGL.GL_LIGHTING);
}
if (wireFrameOnShaded)
{
OpenGL.glDepthMask(0);
}
// Draw the wireframe mesh
//
int vid = 0;
for (int i = 0; i < geom.faceCount; i++)
{
OpenGL.glBegin(OpenGL.GL_LINE_LOOP);
for (int v = 0; v < geom.face_counts[i]; v++)
{
MPoint vertex = geom.vertices[geom.face_connects[vid++]];
OpenGL.glVertex3f((float)vertex[0], (float)vertex[1], (float)vertex[2]);
}
OpenGL.glEnd();
}
// Restore the state
//
if (lightingWasOn)
{
OpenGL.glEnable(OpenGL.GL_LIGHTING);
}
if (wireFrameOnShaded)
{
OpenGL.glDepthMask(1);
}
view.endGL();
}
/////////////////////////////////////////////////////////////////////
//
// Overrides
//
/////////////////////////////////////////////////////////////////////
public override void getDrawRequests(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 = new MDrawData();
apiMesh meshNode = (apiMesh)surfaceShape;
apiMeshGeom geom = meshNode.meshGeom();
if ((null == geom) || (0 == geom.faceCount))
{
MGlobal.displayInfo("NO DrawRequest for apiMesh");
return;
}
// This call creates a prototype draw request that we can fill
// in and then add to the draw queue.
//
MDrawRequest request = getDrawRequest(info); // info.getPrototype(this);
getDrawData(geom, out 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;
// Are we displaying meshes?
if (!info.objectDisplayStatus(M3dView.DisplayObjects.kDisplayMeshes))
{
return;
}
// Use this code to help speed up drawing.
// inUserInteraction() is true for any interaction with
// the viewport, including object or component TRS and camera changes.
// userChangingViewContext() is true only when the user is using view
// context tools (tumble, dolly, track, etc.)
//
if (info.inUserInteraction || info.userChangingViewContext)
{
// User is using view context tools so
// request fast draw and get out
//
request.token = (int)DrawToken.kDrawRedPointAtCenter;
queue.add(request);
return;
}
switch (appearance)
{
case M3dView.DisplayStyle.kWireFrame:
{
request.token = (int)DrawToken.kDrawWireframe;
int activeColorTable = (int)M3dView.ColorTable.kActiveColors;
int dormantColorTable = (int)M3dView.ColorTable.kDormantColors;
switch (displayStatus)
{
case M3dView.DisplayStatus.kLead:
request.setColor(LEAD_COLOR, activeColorTable);
break;
case M3dView.DisplayStatus.kActive:
request.setColor(ACTIVE_COLOR, activeColorTable);
break;
case M3dView.DisplayStatus.kActiveAffected:
request.setColor(ACTIVE_AFFECTED_COLOR, activeColorTable);
break;
case M3dView.DisplayStatus.kDormant:
request.setColor(DORMANT_COLOR, dormantColorTable);
break;
case M3dView.DisplayStatus.kHilite:
request.setColor(HILITE_COLOR, activeColorTable);
break;
default:
break;
}
queue.add(request);
break;
}
case M3dView.DisplayStyle.kGouraudShaded:
{
// Create the smooth shaded draw request
//
request.token = (int)DrawToken.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 = base.material(path);
// If the user currently has the default material enabled on the
// view then use the default material for shading.
//
if (view.usingDefaultMaterial)
{
material = MMaterial.defaultMaterial;
}
// Evaluate the material and if necessary, the texture.
//
material.evaluateMaterial(view, path);
bool drawTexture = true;
if (drawTexture && material.materialIsTextured)
{
material.evaluateTexture(data);
}
request.material = material;
// request.setDisplayStyle( appearance );
bool materialTransparent = false;
material.getHasTransparency(ref materialTransparent);
if (materialTransparent)
{
request.isTransparent = true;
}
queue.add(request);
// create a draw request for wireframe on shaded if
// necessary.
//
if ((displayStatus == M3dView.DisplayStatus.kActive) ||
(displayStatus == M3dView.DisplayStatus.kLead) ||
(displayStatus == M3dView.DisplayStatus.kHilite))
{
MDrawRequest wireRequest = getDrawRequest(info); // info.getPrototype(this);
wireRequest.setDrawData(data);
wireRequest.token = (int)DrawToken.kDrawWireframeOnShaded;
wireRequest.displayStyle = M3dView.DisplayStyle.kWireFrame;
int activeColorTable = (int)M3dView.ColorTable.kActiveColors;
switch (displayStatus)
{
case M3dView.DisplayStatus.kLead:
wireRequest.setColor(LEAD_COLOR, activeColorTable);
break;
case M3dView.DisplayStatus.kActive:
wireRequest.setColor(ACTIVE_COLOR, activeColorTable);
break;
case M3dView.DisplayStatus.kHilite:
wireRequest.setColor(HILITE_COLOR, activeColorTable);
break;
default:
break;
}
queue.add(wireRequest);
}
break;
}
case M3dView.DisplayStyle.kFlatShaded:
request.token = (int)DrawToken.kDrawFlatShaded;
queue.add(request);
break;
case M3dView.DisplayStyle.kBoundingBox:
request.token = (int)DrawToken.kDrawBoundingBox;
queue.add(request);
break;
default:
break;
}
// Add draw requests for components
//
if (!objectAndActiveOnly)
{
// Inactive components
//
if ((appearance == M3dView.DisplayStyle.kPoints) ||
(displayStatus == M3dView.DisplayStatus.kHilite))
{
MDrawRequest vertexRequest = getDrawRequest(info); // info.getPrototype(this);
vertexRequest.setDrawData(data);
vertexRequest.token = (int)DrawToken.kDrawVertices;
vertexRequest.setColor(DORMANT_VERTEX_COLOR,
(int)M3dView.ColorTable.kActiveColors);
queue.add(vertexRequest);
}
// Active components
//
if (((MPxSurfaceShape)surfaceShape).hasActiveComponents)
{
MDrawRequest activeVertexRequest = getDrawRequest(info); // info.getPrototype(this);
activeVertexRequest.setDrawData(data);
activeVertexRequest.token = (int)DrawToken.kDrawVertices;
activeVertexRequest.setColor(ACTIVE_VERTEX_COLOR,
(int)M3dView.ColorTable.kActiveColors);
MObjectArray clist = ((MPxSurfaceShape)surfaceShape).activeComponents;
MObject vertexComponent = clist[0]; // Should filter list
activeVertexRequest.component = vertexComponent;
queue.add(activeVertexRequest);
}
}
}
public void drawVertices(MDrawRequest request, M3dView view)
{
MDrawData data = request.drawData();
MVectorArray geom = data.geometry() as MVectorArray;
view.beginGL();
// Query current state so it can be restored
//
bool lightingWasOn = OpenGL.glIsEnabled(OpenGL.GL_LIGHTING) != 0 ? true : false;
if (lightingWasOn)
{
OpenGL.glDisable(OpenGL.GL_LIGHTING);
}
float lastPointSize;
getLastPointSize(out lastPointSize);
// Set the point size of the vertices
//
OpenGL.glPointSize(POINT_SIZE);
// If there is a component specified by the draw request
// then loop over comp (using an MFnComponent class) and draw the
// active vertices, otherwise draw all vertices.
//
MObject comp = request.component;
if (!comp.isNull)
{
MFnSingleIndexedComponent fnComponent = new MFnSingleIndexedComponent(comp);
for (int i = 0; i < fnComponent.elementCount; i++)
{
int index = fnComponent.element(i);
OpenGL.glBegin(OpenGL.GL_POINTS);
MVector point = geom[index];
OpenGL.glVertex3f((float)point[0],
(float)point[1],
(float)point[2]);
OpenGL.glEnd();
MPoint mp = new MPoint(point);
view.drawText(String.Format("{0}", index), mp);
}
}
else
{
for (int i = 0; i < geom.length; i++)
{
OpenGL.glBegin(OpenGL.GL_POINTS);
MVector point = geom[i];
OpenGL.glVertex3f((float)point[0], (float)point[1], (float)point[2]);
OpenGL.glEnd();
}
}
// Restore the state
//
if (lightingWasOn)
{
OpenGL.glEnable(OpenGL.GL_LIGHTING);
}
OpenGL.glPointSize(lastPointSize);
view.endGL();
}
