//
// Description
//
// Returns offsets for the given components to be used my the
// move tool in normal/u/v mode.
//
// Arguments
//
// component - components to calculate offsets for
// direction - array of offsets to be filled
// mode - the type of offset to be calculated
// normalize - specifies whether the offsets should be normalized
//
// Returns
//
// true if the offsets could be calculated, false otherwise
//
// Support the move tools normal/u/v mode (components)
//
public override bool vertexOffsetDirection( MObject component,
MVectorArray direction,
MVertexOffsetMode mode,
bool normalize)
{
bool offsetOkay = false ;
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( component );
if ( component.apiType != MFn.Type.kMeshVertComponent ) {
return false;
}
offsetOkay = true ;
apiMeshGeom geomPtr = meshGeom();
if ( null == geomPtr ) {
return false;
}
// For each vertex add the appropriate offset
//
int count = fnComp.elementCount;
for ( int idx=0; idx<count; idx++ )
{
MVector normal = geomPtr.normals[ fnComp.element(idx) ];
if( mode == MVertexOffsetMode.kNormal ) {
if( normalize ) normal.normalize() ;
direction.append( normal );
}
else {
// Construct an orthonormal basis from the normal
// uAxis, and vAxis are the new vectors.
//
MVector uAxis = new MVector();
MVector vAxis = new MVector();
uint i, j, k;
double a;
normal.normalize();
i = 0;
a = Math.Abs( normal[0] );
if ( a < Math.Abs(normal[1]) )
{
i = 1;
a = Math.Abs(normal[1]);
}
if ( a < Math.Abs(normal[2]) )
{
i = 2;
}
j = (i+1)%3;
k = (j+1)%3;
a = Math.Sqrt(normal[i]*normal[i] + normal[j]*normal[j]);
uAxis[i] = -normal[j]/a;
uAxis[j] = normal[i]/a;
uAxis[k] = 0.0;
vAxis = normal.crossProduct( uAxis );
if ( mode == MVertexOffsetMode.kUTangent ||
mode == MVertexOffsetMode.kUVNTriad )
{
if( normalize ) uAxis.normalize() ;
direction.append( uAxis );
}
if ( mode == MVertexOffsetMode.kVTangent ||
mode == MVertexOffsetMode.kUVNTriad )
{
if( normalize ) vAxis.normalize() ;
direction.append( vAxis );
}
if ( mode == MVertexOffsetMode.kUVNTriad ) {
if( normalize ) normal.normalize() ;
direction.append( normal );
}
}
}
return offsetOkay;
}
//
// Description
//
// Converts the given component values into a selection list of plugs.
// This method is used to map components to attributes.
//
// Arguments
//
// component - the component to be translated to a plug/attribute
// list - a list of plugs representing the passed in component
//
public override void componentToPlugs(MObject component, MSelectionList list)
{
if ( component.hasFn(MFn.Type.kSingleIndexedComponent) ) {
MFnSingleIndexedComponent fnVtxComp = new MFnSingleIndexedComponent( component );
MObject thisNode = thisMObject();
MPlug plug = new MPlug( thisNode, mControlPoints );
// If this node is connected to a tweak node, reset the
// plug to point at the tweak node.
//
convertToTweakNodePlug(plug);
int len = fnVtxComp.elementCount;
for ( int i = 0; i < len; i++ )
{
plug.selectAncestorLogicalIndex((uint)fnVtxComp.element(i), plug.attribute);
list.add(plug);
}
}
}
//
// Description
//
// Transforms the given components. This method is used by
// the move, rotate, and scale tools in component mode.
// The bounding box has to be updated here, so do the normals and
// any other attributes that depend on vertex positions.
//
// Arguments
// mat - matrix to transform the components by
// componentList - list of components to be transformed,
// or an empty list to indicate the whole surface
// cachingMode - how to use the supplied pointCache
// pointCache - if non-null, save or restore points from this list base
// on the cachingMode
//
public override void transformUsing(MMatrix mat,
MObjectArray componentList,
MVertexCachingMode cachingMode,
MPointArray pointCache)
{
apiMeshGeom geomPtr = meshGeom();
bool savePoints = (cachingMode == MVertexCachingMode.kSavePoints);
int i = 0, j = 0;
uint len = componentList.length;
if (cachingMode == MVertexCachingMode.kRestorePoints) {
// restore the points based on the data provided in the pointCache attribute
//
uint cacheLen = pointCache.length;
if (len > 0) {
// traverse the component list
//
for ( i = 0; i < len && j < cacheLen; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
for ( int idx=0; idx<elemCount && j < cacheLen; idx++, ++j ) {
int elemIndex = fnComp.element( idx );
geomPtr.vertices[elemIndex] = pointCache[j];
}
}
} else {
// if the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
for ( int idx = 0; idx < len && j < cacheLen; ++idx, ++j ) {
geomPtr.vertices[idx] = pointCache[j];
}
}
} else {
// Transform the surface vertices with the matrix.
// If savePoints is true, save the points to the pointCache.
//
if (len > 0) {
// Traverse the componentList
//
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
uint elemCount = (uint)fnComp.elementCount;
if (savePoints && 0 == i) {
pointCache.sizeIncrement = elemCount;
}
for ( int idx=0; idx<elemCount; idx++ )
{
int elemIndex = fnComp.element( (int)idx );
if (savePoints) {
pointCache.append(geomPtr.vertices[elemIndex]);
}
geomPtr.vertices[elemIndex].multiplyEqual( mat );
geomPtr.normals[idx] = geomPtr.normals[idx].transformAsNormal( mat );
}
}
} else {
// If the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
if (savePoints) {
pointCache.sizeIncrement = len;
}
for ( int idx = 0; idx < len; ++idx ) {
if (savePoints) {
pointCache.append(geomPtr.vertices[idx]);
}
geomPtr.vertices[idx].multiplyEqual( mat );
geomPtr.normals[idx] = geomPtr.normals[idx].transformAsNormal( mat );
}
}
}
// Retrieve the value of the cached surface attribute.
// We will set the new geometry data into the cached surface attribute
//
// Access the datablock directly. This code has to be efficient
// and so we bypass the compute mechanism completely.
// NOTE: In general we should always go though compute for getting
// and setting attributes.
//
MDataBlock datablock = _forceCache();
MDataHandle cachedHandle = datablock.outputValue( cachedSurface );
apiMeshData cached = cachedHandle.asPluginData as apiMeshData;
MDataHandle dHandle = datablock.outputValue( mControlPoints );
// If there is history then calculate the tweaks necessary for
// setting the final positions of the vertices.
//
if ( hasHistory() && (null != cached) ) {
// Since the shape has history, we need to store the tweaks (deltas)
// between the input shape and the tweaked shape in the control points
// attribute.
//
buildControlPoints( datablock, (int)geomPtr.vertices.length );
MArrayDataHandle cpHandle = new MArrayDataHandle( dHandle );
// Loop through the component list and transform each vertex.
//
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
for ( int idx=0; idx<elemCount; idx++ )
{
int elemIndex = fnComp.element( idx );
cpHandle.jumpToElement( (uint)elemIndex );
MDataHandle pntHandle = cpHandle.outputValue();
double[] pnt = pntHandle.Double3;
MPoint oldPnt = cached.fGeometry.vertices[elemIndex];
MPoint newPnt = geomPtr.vertices[elemIndex];
MVector offset = newPnt.minus( oldPnt );
pnt[0] += offset[0];
pnt[1] += offset[1];
pnt[2] += offset[2];
pntHandle.Double3 = pnt;
}
}
}
// Copy outputSurface to cachedSurface
//
if ( null == cached ) {
MGlobal.displayInfo("NULL cachedSurface data found");
}
else {
cached.fGeometry = geomPtr;
}
MPlug pCPs = new MPlug( thisMObject(), mControlPoints );
pCPs.setValue(dHandle);
// Moving vertices will likely change the bounding box.
//
computeBoundingBox( datablock );
// Tell Maya the bounding box for this object has changed
// and thus "boundingBox()" needs to be called.
//
childChanged( MChildChanged.kBoundingBoxChanged );
}
//
// Description
//
// Transforms the given components. This method is used by
// the move, rotate, and scale tools in component mode when the
// tweaks for the shape are stored on a separate tweak node.
// The bounding box has to be updated here, so do the normals and
// any other attributes that depend on vertex positions.
//
// Arguments
// mat - matrix to transform the components by
// componentList - list of components to be transformed,
// or an empty list to indicate the whole surface
// cachingMode - how to use the supplied pointCache
// pointCache - if non-null, save or restore points from this list base
// on the cachingMode
// handle - handle to the attribute on the tweak node where the
// tweaks should be stored
//
public override void tweakUsing( MMatrix mat,
MObjectArray componentList,
MVertexCachingMode cachingMode,
MPointArray pointCache,
MArrayDataHandle handle)
{
apiMeshGeom geomPtr = meshGeom();
bool savePoints = (cachingMode == MVertexCachingMode.kSavePoints);
bool updatePoints = (cachingMode == MVertexCachingMode.kUpdatePoints);
MArrayDataBuilder builder = handle.builder();
MPoint delta = new MPoint();
MPoint currPt = new MPoint();
MPoint newPt = new MPoint();
int i=0;
uint len = componentList.length;
int cacheIndex = 0;
uint cacheLen = (null != pointCache) ? pointCache.length : 0;
if (cachingMode == MVertexCachingMode.kRestorePoints) {
// restore points from the pointCache
//
if (len > 0) {
// traverse the component list
//
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
for ( int idx=0; idx<elemCount && cacheIndex < cacheLen; idx++, cacheIndex++) {
int elemIndex = fnComp.element( idx );
MDataHandle hdl = builder.addElement((uint)elemIndex);
double[] pt = hdl.Double3;
MPoint cachePt = pointCache[cacheIndex];
pt[0] += cachePt.x;
pt[1] += cachePt.y;
pt[2] += cachePt.z;
hdl.Double3 = pt;
}
}
} else {
// if the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
for ( uint idx = 0; idx < len && idx < cacheLen; ++idx ) {
MDataHandle hdl = builder.addElement(idx);
double[] pt = hdl.Double3;
MPoint cachePt = pointCache[cacheIndex];
pt[0] += cachePt.x;
pt[1] += cachePt.y;
pt[2] += cachePt.z;
hdl.Double3 = pt;
}
}
} else {
// Tweak the points. If savePoints is true, also save the tweaks in the
// pointCache. If updatePoints is true, add the new tweaks to the existing
// data in the pointCache.
//
if (len > 0) {
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
if (savePoints) {
pointCache.sizeIncrement = (uint)elemCount;
}
for ( int idx=0; idx<elemCount; idx++ )
{
int elemIndex = fnComp.element( idx );
MDataHandle hdl = builder.addElement((uint)elemIndex);
double[] pt = hdl.Double3;
currPt = newPt = geomPtr.vertices[elemIndex];
newPt.multiplyEqual( mat );
delta.x = newPt.x - currPt.x;
delta.y = newPt.y - currPt.y;
delta.z = newPt.z - currPt.z;
pt[0] += delta.x;
pt[1] += delta.y;
pt[2] += delta.z;
hdl.Double3 = pt;
if (savePoints) {
// store the points in the pointCache for undo
//
pointCache.append(delta*(-1.0));
} else if (updatePoints && cacheIndex < cacheLen) {
MPoint cachePt = pointCache[cacheIndex];
cachePt[0] -= delta.x;
cachePt[1] -= delta.y;
cachePt[2] -= delta.z;
cacheIndex++;
}
}
}
} else {
// if the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
if (savePoints) {
pointCache.sizeIncrement = len;
}
for ( int idx = 0; idx < len; ++idx ) {
MDataHandle hdl = builder.addElement((uint)idx);
double[] pt = hdl.Double3;
currPt = newPt = geomPtr.vertices[idx];
newPt.multiplyEqual( mat );
delta.x = newPt.x - currPt.x;
delta.y = newPt.y - currPt.y;
delta.z = newPt.z - currPt.z;
pt[0] += delta.x;
pt[1] += delta.y;
pt[2] += delta.z;
hdl.Double3 = pt;
if (savePoints) {
// store the points in the pointCache for undo
//
pointCache.append(delta*-1.0);
} else if (updatePoints && idx < cacheLen) {
MPoint cachePt = pointCache[idx];
cachePt[0] -= delta.x;
cachePt[1] -= delta.y;
cachePt[2] -= delta.z;
}
}
}
}
// Set the builder into the handle.
//
handle.set(builder);
// Tell Maya the bounding box for this object has changed
// and thus "boundingBox()" needs to be called.
//
childChanged( MChildChanged.kBoundingBoxChanged );
}
public override void componentToPlugs(MObject component, MSelectionList list)
//
// Description
//
// Converts the given component values into a selection list of plugs.
// This method is used to map components to attributes.
//
// Arguments
//
// component - the component to be translated to a plug/attribute
// list - a list of plugs representing the passed in component
//
{
if ( component.hasFn(MFn.Type.kSingleIndexedComponent) ) {
MFnSingleIndexedComponent fnVtxComp = new MFnSingleIndexedComponent( component );
MObject thisNode = thisMObject();
MPlug plug = new MPlug( thisNode, mControlPoints );
// If this node is connected to a tweak node, reset the
// plug to point at the tweak node.
//
convertToTweakNodePlug(plug);
int len = fnVtxComp.elementCount;
for ( int i = 0; i < len; i++ )
{
plug.selectAncestorLogicalIndex((uint)fnVtxComp.element(i), plug.attribute);
list.add(plug);
}
}
}
public override void tweakUsing( MMatrix mat,
MObjectArray componentList,
MVertexCachingMode cachingMode,
MPointArray pointCache,
MArrayDataHandle handle )
//
// Description
//
// Transforms the given components. This method is used by
// the move, rotate, and scale tools in component mode when the
// tweaks for the shape are stored on a separate tweak node.
// The bounding box has to be updated here, so do the normals and
// any other attributes that depend on vertex positions.
//
// Arguments
// mat - matrix to transform the components by
// componentList - list of components to be transformed,
// or an empty list to indicate the whole surface
// cachingMode - how to use the supplied pointCache
// pointCache - if non-null, save or restore points from this list base
// on the cachingMode
// handle - handle to the attribute on the tweak node where the
// tweaks should be stored
//
{
apiMeshGeom geomPtr = meshGeom();
bool savePoints = (cachingMode == MVertexCachingMode.kSavePoints);
bool updatePoints = (cachingMode == MVertexCachingMode.kUpdatePoints);
MArrayDataBuilder builder = handle.builder();
MPoint delta = new MPoint();
MPoint currPt = new MPoint();
MPoint newPt = new MPoint();
int i=0;
uint len = componentList.length;
int cacheIndex = 0;
uint cacheLen = (null != pointCache) ? pointCache.length : 0;
if (cachingMode == MVertexCachingMode.kRestorePoints) {
// restore points from the pointCache
//
if (len > 0) {
// traverse the component list
//
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
for ( int idx=0; idx<elemCount && cacheIndex < cacheLen; idx++, cacheIndex++) {
int elemIndex = fnComp.element( idx );
MDataHandle hdl = builder.addElement((uint)elemIndex);
double[] pt = hdl.Double3;
MPoint cachePt = pointCache[cacheIndex];
pt[0] += cachePt.x;
pt[1] += cachePt.y;
pt[2] += cachePt.z;
hdl.Double3 = pt;
}
}
} else {
// if the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
for ( uint idx = 0; idx < len && idx < cacheLen; ++idx ) {
MDataHandle hdl = builder.addElement(idx);
double[] pt = hdl.Double3;
MPoint cachePt = pointCache[cacheIndex];
pt[0] += cachePt.x;
pt[1] += cachePt.y;
pt[2] += cachePt.z;
hdl.Double3 = pt;
}
}
} else {
// Tweak the points. If savePoints is true, also save the tweaks in the
// pointCache. If updatePoints is true, add the new tweaks to the existing
// data in the pointCache.
//
if (len > 0) {
for ( i=0; i<len; i++ )
{
MObject comp = componentList[i];
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( comp );
int elemCount = fnComp.elementCount;
if (savePoints) {
pointCache.sizeIncrement = (uint)elemCount;
}
for ( int idx=0; idx<elemCount; idx++ )
{
int elemIndex = fnComp.element( idx );
MDataHandle hdl = builder.addElement((uint)elemIndex);
double[] pt = hdl.Double3;
currPt = newPt = geomPtr.vertices[elemIndex];
newPt.multiplyEqual( mat );
delta.x = newPt.x - currPt.x;
delta.y = newPt.y - currPt.y;
delta.z = newPt.z - currPt.z;
pt[0] += delta.x;
pt[1] += delta.y;
pt[2] += delta.z;
hdl.Double3 = pt;
if (savePoints) {
// store the points in the pointCache for undo
//
pointCache.append(delta*(-1.0));
} else if (updatePoints && cacheIndex < cacheLen) {
MPoint cachePt = pointCache[cacheIndex];
cachePt[0] -= delta.x;
cachePt[1] -= delta.y;
cachePt[2] -= delta.z;
cacheIndex++;
}
}
}
} else {
// if the component list is of zero-length, it indicates that we
// should transform the entire surface
//
len = geomPtr.vertices.length;
if (savePoints) {
pointCache.sizeIncrement = len;
}
for ( int idx = 0; idx < len; ++idx ) {
MDataHandle hdl = builder.addElement((uint)idx);
double[] pt = hdl.Double3;
currPt = newPt = geomPtr.vertices[idx];
newPt.multiplyEqual( mat );
delta.x = newPt.x - currPt.x;
delta.y = newPt.y - currPt.y;
delta.z = newPt.z - currPt.z;
pt[0] += delta.x;
pt[1] += delta.y;
pt[2] += delta.z;
hdl.Double3 = pt;
if (savePoints) {
// store the points in the pointCache for undo
//
pointCache.append(delta*-1.0);
} else if (updatePoints && idx < cacheLen) {
MPoint cachePt = pointCache[idx];
cachePt[0] -= delta.x;
cachePt[1] -= delta.y;
cachePt[2] -= delta.z;
}
}
}
}
// Set the builder into the handle.
//
handle.set(builder);
// Tell Maya the bounding box for this object has changed
// and thus "boundingBox()" needs to be called.
//
childChanged( MChildChanged.kBoundingBoxChanged );
}
// Support the move tools normal/u/v mode (components)
//
public override bool vertexOffsetDirection( MObject component,
MVectorArray direction,
MVertexOffsetMode mode,
bool normalize )
//
// Description
//
// Returns offsets for the given components to be used my the
// move tool in normal/u/v mode.
//
// Arguments
//
// component - components to calculate offsets for
// direction - array of offsets to be filled
// mode - the type of offset to be calculated
// normalize - specifies whether the offsets should be normalized
//
// Returns
//
// true if the offsets could be calculated, false otherwise
//
{
bool offsetOkay = false ;
MFnSingleIndexedComponent fnComp = new MFnSingleIndexedComponent( component );
if ( component.apiType != MFn.Type.kMeshVertComponent ) {
return false;
}
offsetOkay = true ;
apiMeshGeom geomPtr = meshGeom();
if ( null == geomPtr ) {
return false;
}
// For each vertex add the appropriate offset
//
int count = fnComp.elementCount;
for ( int idx=0; idx<count; idx++ )
{
MVector normal = geomPtr.normals[ fnComp.element(idx) ];
if( mode == MVertexOffsetMode.kNormal ) {
if( normalize ) normal.normalize() ;
direction.append( normal );
}
else {
// Construct an orthonormal basis from the normal
// uAxis, and vAxis are the new vectors.
//
MVector uAxis = new MVector();
MVector vAxis = new MVector();
uint i, j, k;
double a;
normal.normalize();
i = 0;
a = Math.Abs( normal[0] );
if ( a < Math.Abs(normal[1]) )
{
i = 1;
a = Math.Abs(normal[1]);
}
if ( a < Math.Abs(normal[2]) )
{
i = 2;
}
j = (i+1)%3;
k = (j+1)%3;
a = Math.Sqrt(normal[i]*normal[i] + normal[j]*normal[j]);
uAxis[i] = -normal[j]/a;
uAxis[j] = normal[i]/a;
uAxis[k] = 0.0;
vAxis = normal.crossProduct( uAxis );
if ( mode == MVertexOffsetMode.kUTangent ||
mode == MVertexOffsetMode.kUVNTriad )
{
if( normalize ) uAxis.normalize() ;
direction.append( uAxis );
}
if ( mode == MVertexOffsetMode.kVTangent ||
mode == MVertexOffsetMode.kUVNTriad )
{
if( normalize ) vAxis.normalize() ;
direction.append( vAxis );
}
if ( mode == MVertexOffsetMode.kUVNTriad ) {
if( normalize ) normal.normalize() ;
direction.append( normal );
}
}
}
return offsetOkay;
}
//
// Description:
//
// Component (vertex) drawing routine
//
// Arguments:
//
// request - request to be drawn
// view - view to draw into
//
public void drawVertices( MDrawRequest request, M3dView view )
{
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 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();
}
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 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();
}
