#include
<MFnNurbsSurface.h>
This is the function set for NURBS (NonUniform Rational Bspline) surfaces.
The shape of a NURBS surface is defined by an array of CVs (control vertices), an array of knot values in the U direction and an array of knot values in the V direction, a degree in U and in V, and a form in U and in V.
The U and V knot vectors for NURBS surfaces are of size (spansInU + 2*degreeInU 1) and (spansInV + 2*degreeInV 1). Note: spans = numCVs  degree.
There are 3 possible "forms" for the surface in the U and V directions: open, closed and periodic. These forms are described below. Note that the descriptions below apply to both the U and V directions.
The open and closed forms are quite similar, and in fact a closed surface will become and open surface if either the first or last CV is moved so that they are no longer coincident. To create an open or closed surface, of degree N, with M spans, you must provide M+N CVs. This implies that for a degree N surface, you must specify at least N+1 CVs to get a surface with a single span.
The number of knots required for the surface is M + 2N  1. If you want the surface to start exactly at the first CV and end exactly at the last CV, then the knot vector must be structured to have degree N "multiplicity" at the beginning and end. This means that the first N knots must be identical, and the last N knots must be identical.
A periodic surface is a special case of a closed surface. Instead of having just the first and last CVs coincident, the last N CVs in the surface, where N is equal to the degree, overlap the first N CVs. This results in a surface with no tangent break where the ends meet. The last N CVs in a periodic surface are permanently bound to the first N CVs, and Maya will not allow those last N CVs to be repositioned. If one or more of the first N CVs of the surface are repositioned, the overlapping CV's will remain bound, and will also be moved.
In order to create a periodic surface, you must specify at least 2N+1 CVs, so that that last N can overlap the first N and you still have 1 nonoverlapping CV left. The number of CVs required to create a periodic surface is still N+M (with a lower limit of 2N+1), but you must ensure that the positions of the last N CVs are identical to the positions of the first N.
You still need M + 2N  1 knots for a periodic surface, but the knot values required are more restrictive than for open or closed surfaces because of the overlap of the last N CVs. The first N knots should be specified at the beginning of the knot array as values { (N1), (N2), ... 0 } in order to implement the overlap. Additionally there can be no knot multiplicity at the end of the surface, because that would compromise the tangent continuity property.
Managing different knot representations in external applications
Note that some third party applications use a different format for knots, where the number of knots required for a surface is M+2N+1 rather than M+2N1 as used in Maya. Both knot representations are equivalent mathematically. To convert from one of these external representations into the Maya representation, simply omit the first and last knots from the external representation when creating the Maya representation. To convert from the Maya representation into the external representation, add two new knots at the beginning and end of the Maya knot sequence. The value of these new knots depends on the existing knot sequence. For a knot sequence with multiple end knots, simply duplicate the existing first and last knots once more, for example:
Maya representation: {0,0,0,...,N,N,N} External representation: {0,0,0,0,...,N,N,N,N}
For a knot sequence with uniform end knots, create the new knots offset at an interval equal to the existing first and last knot intervals, for example:
Maya representation: {0,1,2,...,N,N+1,N+2} External representation: {1,0,1,2,...,N,N+1,N+2,N+3}
Public Types 

enum  Form
{ kInvalid = 0, kOpen, kClosed, kPeriodic, kLast } 
Forms that a surface may take in a given
parametric direction. More... 

enum  BoundaryType
{ kInvalidBoundary = 0, kOuter, kInner, kSegment, kClosedSegment } 
Boundary types for trimmed surfaces.
More... 

Public Member Functions 

virtual MFn::Type  type () const 
Function set type. 

virtual  ~MFnNurbsSurface () 
Destructor. 

MFnNurbsSurface ()  
Default constructor. 

MFnNurbsSurface (MObject &object, MStatus *ReturnStatus=NULL)  
Constructor. 

MFnNurbsSurface (const MDagPath &object, MStatus *ret=NULL)  
Constructor. 

MObject  create (const MPointArray &controlVertices, const MDoubleArray &uKnotSequences, const MDoubleArray &vKnotSequences, unsigned int degreeInU, unsigned int degreeInV, Form formU, Form formV, bool createRational, MObject parentOrOwner=MObject::kNullObj, MStatus *ReturnStatus=NULL) 
MObject  copy (const MObject &source, MObject parentOrOwner=MObject::kNullObj, MStatus *ReturnStatus=NULL) 
MObject  cv (unsigned int indexU, unsigned int indexV, MStatus *ReturnStatus=NULL) 
MObject  cvsInU (unsigned int startIndex, unsigned int endIndex, unsigned int rowIndex, MStatus *ReturnStatus=NULL) 
MObject  cvsInV (unsigned int startIndex, unsigned int endIndex, unsigned int rowIndex, MStatus *ReturnStatus=NULL) 
MStatus  getCVs (MPointArray &array, MSpace::Space space=MSpace::kObject) const 
MStatus  setCVs (const MPointArray &array, MSpace::Space space=MSpace::kObject) 
MStatus  getCV (unsigned int indexU, unsigned int indexV, MPoint &pnt, MSpace::Space space=MSpace::kObject) const 
MStatus  setCV (unsigned int indexU, unsigned int indexV, MPoint &pnt, MSpace::Space space=MSpace::kObject) const 
Form  formInU (MStatus *ReturnStatus=NULL) const 
Form  formInV (MStatus *ReturnStatus=NULL) const 
bool  isBezier (MStatus *ReturnStatus=NULL) const 
bool  isUniform (MStatus *ReturnStatus=NULL) const 
bool  isKnotU (double param, MStatus *ReturnStatus=NULL) const 
bool  isKnotV (double param, MStatus *ReturnStatus=NULL) const 
bool  isParamOnSurface (double paramU, double paramV, MStatus *ReturnStatus=NULL) const 
MStatus  getKnotDomain (double &startU, double &endU, double &startV, double &endV) const 
int  degreeU (MStatus *ReturnStatus=NULL) const 
int  degreeV (MStatus *ReturnStatus=NULL) const 
int  numSpansInU (MStatus *ReturnStatus=NULL) const 
int  numSpansInV (MStatus *ReturnStatus=NULL) const 
int  numNonZeroSpansInU (MStatus *ReturnStatus=NULL) const 
int  numNonZeroSpansInV (MStatus *ReturnStatus=NULL) const 
int  numCVsInU (MStatus *ReturnStatus=NULL) const 
int  numCVsInV (MStatus *ReturnStatus=NULL) const 
int  numKnotsInU (MStatus *ReturnStatus=NULL) const 
int  numKnotsInV (MStatus *ReturnStatus=NULL) const 
MStatus  getKnotsInU (MDoubleArray &array) const 
MStatus  getKnotsInV (MDoubleArray &array) const 
MStatus  setKnotsInU (const MDoubleArray &array, unsigned int startIndex, unsigned int endIndex) 
MStatus  setKnotsInV (const MDoubleArray &array, unsigned int startIndex, unsigned int endIndex) 
double  knotInU (unsigned int index, MStatus *ReturnStatus=NULL) const 
double  knotInV (unsigned int index, MStatus *ReturnStatus=NULL) const 
MStatus  setKnotInU (unsigned int index, double param) 
MStatus  setKnotInV (unsigned int index, double param) 
MStatus  removeKnotInU (double atThisParam, bool removeAll=false) 
MStatus  removeKnotInV (double atThisParam, bool removeAll=false) 
MStatus  removeOneKnotInU (double atThisParam) 
MStatus  removeOneKnotInV (double atThisParam) 
MVector  normal (double paramInU, double paramInV, MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MStatus  getTangents (double paramInU, double paramInV, MVector &vectorInU, MVector &vectorInV, MSpace::Space space=MSpace::kObject) const 
MStatus  getDerivativesAtParm (double paramInU, double paramInV, MPoint &pos, MVector &dU, MVector &dV, MSpace::Space space, MVector *dUU=NULL, MVector *dVV=NULL, MVector *dUV=NULL) const 
bool  isFoldedOnBispan () const 
double  area (double tolerance=1.0e3, MStatus *ReturnStatus=NULL) const 
double  area (MSpace::Space space, double tolerance=1.0e3, MStatus *ReturnStatus=NULL) const 
MPoint  closestPoint (const MPoint &toThisPoint, double *paramU=NULL, double *paramV=NULL, bool ignoreTrimBoundaries=false, double tolerance=1.0e3, MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MPoint  closestPoint (const MPoint &toThisPoint, bool paramAsStart, double *paramU, double *paramV, bool ignoreTrimBoundaries=false, double tolerance=1.0e3, MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
bool  isPointOnSurface (const MPoint &point, double tolerance=1.0e3, MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MStatus  getParamAtPoint (const MPoint &atThisPoint, double ¶mU, double ¶mV, MSpace::Space space=MSpace::kObject) const 
This method is obsolete. 

MStatus  getParamAtPoint (const MPoint &atThisPoint, double ¶mU, double ¶mV, bool ignoreTrimBoundaries, MSpace::Space space=MSpace::kObject, double tolerance=1.0e3) const 
MStatus  getPointAtParam (double paramU, double paramV, MPoint &point, MSpace::Space space=MSpace::kObject) const 
double  distanceToPoint (const MPoint &pt, MSpace::Space space=MSpace::kObject, MStatus *ReturnStatus=NULL) const 
MObject  tesselate (MTesselationParams &parms=MTesselationParams::fsDefaultTesselationParams, MObject parentOrOwner=MObject::kNullObj, MStatus *ReturnStatus=NULL) 
bool  intersect (const MPoint &rayStartingPoint, const MVector &alongThisDirection, double &u, double &v, MPoint &intersectionData, double tolerance=1.0e3, MSpace::Space space=MSpace::kObject, bool calculateDistance=false, double *distance=NULL, bool calculateExactHit=false, bool *wasExactHit=NULL, MStatus *ReturnStatus=NULL) const 
bool  intersect (const MPoint &rayStartingPoint, const MVector &alongThisDirection, MDoubleArray &u, MDoubleArray &v, MPointArray &intersectionData, double tolerance=1.0e3, MSpace::Space space=MSpace::kObject, bool calculateDistance=false, MDoubleArray *distances=NULL, bool calculateExactHit=false, bool *wasExactHit=NULL, MStatus *ReturnStatus=NULL) const 
bool  hasHistoryOnCreate (MStatus *ReturnStatus=NULL) 
MStatus  updateSurface () 
bool  isTrimmedSurface (MStatus *ReturnStatus=NULL) 
unsigned int  numRegions (MStatus *ReturnStatus=NULL) 
bool  isFlipNorm (unsigned int region, MStatus *ReturnStatus=NULL) 
unsigned int  numBoundaries (unsigned int region, MStatus *ReturnStatus=NULL) 
BoundaryType  boundaryType (unsigned int region, unsigned int boundary, MStatus *ReturnStatus=NULL) 
unsigned int  numEdges (unsigned int region, unsigned int boundary, MStatus *ReturnStatus=NULL) 
MObjectArray  edge (unsigned int region, unsigned int boundary, unsigned int edge, bool paramEdge=false, MStatus *ReturnStatus=NULL) 
bool  isPointInTrimmedRegion (double u, double v, MStatus *ReturnStatus=NULL) 
MStatus  getTrimBoundaries (MTrimBoundaryArray &result, unsigned int region, bool paramEdge=true) 
MStatus  trimWithBoundaries (const MTrimBoundaryArray &mBoundaries, bool flipNormal=false, double e_tol=1e3, double pe_tol=1e5) 
MStatus  projectCurve (MDagPath &curve, MVector *direction=NULL, bool constructionHistory=false) 
MStatus  trim (MDoubleArray &locatorU, MDoubleArray &locatorV, bool constructionHistory=false) 
unsigned int  numPatches (MStatus *ReturnStatus=NULL) const 
unsigned int  numPatchesInU (MStatus *ReturnStatus=NULL) const 
unsigned int  numPatchesInV (MStatus *ReturnStatus=NULL) const 
int  numUVs (MStatus *ReturnStatus=NULL) const 
MStatus  setUVs (const MFloatArray &uArray, const MFloatArray &vArray) 
MStatus  getUVs (MFloatArray &uArray, MFloatArray &vArray) const 
MStatus  setUV (int uvId, float u, float v) 
MStatus  getUV (int uvId, float &u, float &v) const 
MStatus  getPatchUV (int patchId, int cornerIndex, float &u, float &v) const 
MStatus  getPatchUVs (int patchId, MFloatArray &uArray, MFloatArray &vArray) const 
MStatus  getPatchUVid (int patchId, int cornerIndex, int &uvId) const 
MStatus  assignUV (int patchId, int cornerIndex, int uvId) 
MStatus  assignUVs (const MIntArray &uvCounts, const MIntArray &uvIds) 
MStatus  clearUVs () 
MStatus  getAssignedUVs (MIntArray &uvCounts, MIntArray &uvIds) const 
MObject  tesselate (MTesselationParams &parms, MStatus *ReturnStatus) 
This method is obsolete. 

MObject  getDataObject () const 
MFnNurbsSurface (const MObject &object, MStatus *ret=NULL)  
Constructor. 

Protected Member Functions 

virtual const char *  className () const 
Class name. 
MFnNurbsSurface::~MFnNurbsSurface  (  )  [virtual] 
Destructor.
Destructor.
Constructor.
Class constructor that initializes the function set to the given MObject.
[in]  object  The MObject to attach the function set to 
[out]  ReturnStatus  the return status 
Constructor.
Class constructor that initializes the function set to the given constant MDagPath object.
[in]  object  The const MDagPath to attach the function set to 
[out]  ReturnStatus  The return status 
Constructor.
Class constructor that initializes the function set to the given MObject.
[in]  object  The MObject to attach the function set to 
[out]  ReturnStatus  the return status 
MFn::Type MFnNurbsSurface::type  (  )  const [virtual] 
const char * MFnNurbsSurface::className  (  )  const [protected, virtual] 
MObject MFnNurbsSurface::create  (  const MPointArray &  controlVertices,  
const MDoubleArray &  uKnotSequences,  
const MDoubleArray &  vKnotSequences,  
unsigned int  degreeInU,  
unsigned int  degreeInV,  
MFnNurbsSurface::Form  formU,  
MFnNurbsSurface::Form  formV,  
bool  createRational,  
MObject  parentOrOwner = MObject::kNullObj , 

MStatus *  ReturnStatus =
NULL 

) 
Creates a nurbs surface from the specified data and sets this function set to operate on the new surface.
The parentOrOwner argument is used to specify the owner of the new surface.
If the parentOrOwner is kNurbsSurfaceData then the created surface will be of type kNurbsSurfaceGeom and will be returned. The parentOrOwner will become the owner of the new surface.
If parentOrOwner is NULL then a new transform will be created and returned which will be the parent for the surface. The new transform will be added to the DAG.
If parentOrOwner is a DAG node then the new surface will be returned and the parentOrOwner will become its parent.
Note that the knot vectors must be of length spans + 2*degree  1.
[in]  controlVertices  an array of control vertices 
[in]  uKnotSequences  an array of U knot values 
[in]  vKnotSequences  an array of V knot values 
[in]  degreeInU  degree of first set of basis functions 
[in]  degreeInV  degree of second set of basis functions 
[in]  formU  open, closed, periodic in U 
[in]  formV  open, closed, periodic in V 
[in]  createRational  create as rational (true) or nonrational (false) surface 
[in]  parentOrOwner  specifies what to do with the surface. If a DAG object or NULL is given then a transform will be created for the new surface and placed under the specified (optional)parent. If kNurbsSurfaceData is given then the surface will become its data. 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::copy  (  const MObject &  source,  
MObject  parentOrOwner = MObject::kNullObj , 

MStatus *  ReturnStatus =
NULL 

) 
This method creates a copy of a nurbs surface.
The parentOrOwner argument is used to specify the owner of the new surface.
If the parentOrOwner is kNurbsSurfaceData then the created surface will be of type kNurbsSurfaceGeom and will be returned. The parentOrOwner will become the owner of the new surface.
If parentOrOwner is NULL then a new transform will be created and returned which will be the parent for the surface. The new transform will be added to the DAG.
If parentOrOwner is a DAG node then the new surface will be returned and the parentOrOwner will become its parent.
[in]  source  the surface to be copied 
[in]  parentOrOwner  the DAG parent or kNurbsSurfaceData the new surface will belong to 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::cv  (  unsigned int  indexU,  
unsigned int  indexV,  
MStatus *  ReturnStatus =
NULL 

) 
Returns a component for the specified CV.
Components are used to specify one or more CVs and are usefull in operating on groups of noncontiguous CVs for a curve or surface. Components do not contain any information about the surface that they refer to so an MDagPath must be specified when dealing with components.
[in]  indexU  U index of CV 
[in]  indexV  V index of CV 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::cvsInU  (  unsigned int  startIndex,  
unsigned int  endIndex,  
unsigned int  rowIndex,  
MStatus *  ReturnStatus =
NULL 

) 
Returns a component for the specified CVs.
Components are used to specify one or more CVs and are usefull in operating on groups of noncontiguous CVs for a curve or surface. Components do not contain any information about the surface that they refer to so an MDagPath must be specified when dealing with components.
[in]  startIndex  start CV index in U 
[in]  endIndex  end CV index in U 
[in]  rowIndex  row index 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::cvsInV  (  unsigned int  startIndex,  
unsigned int  endIndex,  
unsigned int  rowIndex,  
MStatus *  ReturnStatus =
NULL 

) 
Returns a component for the specified CVs on the given V direction.
Components are used to specify one or more CVs and are usefull in operating on groups of noncontiguous CVs for a curve or surface. Components do not contain any information about the surface that they refer to so an MDagPath must be specified when dealing with components.
[in]  startIndex  start CV index in V 
[in]  endIndex  end CV index in V 
[in]  rowIndex  row index 
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::getCVs  (  MPointArray &  array,  
MSpace::Space  space =
MSpace::kObject 

)  const 
Get the positions of the CVs on this surface. The returned group can be accessed via the MPointArray class. numCVsInU() * numCVsInV() points will be returned. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".
Any modifications to these CVs will not affect this surface. setCVs should be called to modify the original surface. updateSurface should be called to cause the surface to redraw itself.
[out]  array  the array of point values for the CVs 
[in]  space  specifies the coordinate system for this operation 
MStatus MFnNurbsSurface::setCVs  (  const MPointArray &  array,  
MSpace::Space  space =
MSpace::kObject 

) 
Set the CVs for this surface to the given points. numCVsInU() * numCVsInV() points must be provided. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".
[in]  array  The array of point values of the CVs 
[in]  space  specifies the coordinate system for this operation 
MStatus MFnNurbsSurface::getCV  (  unsigned int  indexU,  
unsigned int  indexV,  
MPoint &  pnt,  
MSpace::Space  space =
MSpace::kObject 

)  const 
Get the location of the specified CV.
[in]  indexU  U index of CV 
[in]  indexV  V index of CV 
[out]  pnt  storage for the CV location 
[in]  space  coordinate space for the CV 
MStatus MFnNurbsSurface::setCV  (  unsigned int  indexU,  
unsigned int  indexV,  
MPoint &  pt,  
MSpace::Space  space =
MSpace::kObject 

)  const 
Set the location of the specified CV.
If the surface is periodic then overlapping CVs will be ignored, that is, only indices in U and V that are less that the number of spans in U and V respectively will be considered.
[in]  indexU  U index of CV 
[in]  indexV  V index of CV 
[in]  pt  new location for the CV 
[in]  space  coordinate space for the CV 
MFnNurbsSurface::Form MFnNurbsSurface::formInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Return the form of this surface in U. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.
[out]  ReturnStatus  Status code 
MFnNurbsSurface::Form MFnNurbsSurface::formInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Return the form of this surface in V. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isBezier  (  MStatus *  ReturnStatus =
NULL 
)  const 
Determine if the knot spacing gives us Bezier surface.
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isUniform  (  MStatus *  ReturnStatus =
NULL 
)  const 
Determine if the knot spacing is uniform.
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isKnotU  (  double  param,  
MStatus *  ReturnStatus =
NULL 

)  const 
Check if the specified parameter value is a knot value.
[in]  param  parameter value to test 
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isKnotV  (  double  param,  
MStatus *  ReturnStatus =
NULL 

)  const 
Check if the specified parameter value is a knot value.
[in]  param  parameter value to test 
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isParamOnSurface  (  double  paramU,  
double  paramV,  
MStatus *  ReturnStatus =
NULL 

)  const 
Check if the specified parameter is on this surface.
[in]  paramU  U parameter value 
[in]  paramV  V parameter value 
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::getKnotDomain  (  double &  startU,  
double &  endU,  
double &  startV,  
double &  endV  
)  const 
Returns the maximum and minimum U and V paramter values for this surface.
[out]  startU  Start U parameter value 
[out]  endU  End U parameter value 
[out]  startV  Start V parameter value 
[out]  endV  End V parameter value 
int MFnNurbsSurface::degreeU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the degree of the surface in U (1  3).
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::degreeV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the degree of the surface in V (1  3).
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numSpansInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of spans in the u direction.
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numSpansInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of spans in the v direction.
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numNonZeroSpansInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of nonzero spans in the U direction. This value will be equivalent to the value returned by numSpansInU() if all of the internal (nonend) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by numSpansInU(). You can use the number of nonzero spans to count the number of visual spans on the surface in the U direction, since the empty (zero) spans do not appear as a separate span/patch in the display.
Further, the NURBS face components have the valid index range bounded by this value in U direction (i.e., the NURBS face component index runs from 0 to numNonEmptySpansInU()1 inclusivelly.)
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numNonZeroSpansInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of nonzero spans in the V direction. This value will be equivalent to the value returned by numSpansInV() if all of the internal (nonend) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by numSpansInV(). You can use the number of nonzero spans to count the number of visual spans on the surface in the V direction, since the empty (zero) spans do not appear as a separate span/patch in the display.
Further, the NURBS face components have the valid index range bounded by this value in V direction (i.e., the NURBS face component index runs from 0 to numNonEmptySpansInV()1 inclusivelly.)
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numCVsInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of CVs in the U direction (degree + spans).
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numCVsInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of CVs in the V direction (degree + spans).
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numKnotsInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of knots in U including multiple end knots (spans + 2 * degree  1).
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numKnotsInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of knots in V including multiple end knots (spans + 2 * degree  1).
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::getKnotsInU  (  MDoubleArray &  array  )  const 
Get the knots along the U direction for this surface.
[out]  array  Storage for the knot values 
MStatus MFnNurbsSurface::getKnotsInV  (  MDoubleArray &  array  )  const 
Get the knots along the V direction for this surface.
[out]  array  Storage for the knot values 
MStatus MFnNurbsSurface::setKnotsInU  (  const MDoubleArray &  array,  
unsigned int  startIndex,  
unsigned int  endIndex  
) 
Set the specified U knot values for this surface.
[in]  array  The knot values to be set 
[in]  startIndex  The start knot index 
[in]  endIndex  The end knot index 
MStatus MFnNurbsSurface::setKnotsInV  (  const MDoubleArray &  array,  
unsigned int  startIndex,  
unsigned int  endIndex  
) 
Set the specified V knot values for this surface.
[in]  array  The knot values to be set 
[in]  startIndex  The start knot index 
[in]  endIndex  The end knot index 
double MFnNurbsSurface::knotInU  (  unsigned int  index,  
MStatus *  ReturnStatus =
NULL 

)  const 
Retrieve the given knot value from this surface at the specified U index. Knots are indexed from 0 to numKnots1.
[in]  index  The U index of the knot value to get 
[out]  ReturnStatus  Status code 
double MFnNurbsSurface::knotInV  (  unsigned int  index,  
MStatus *  ReturnStatus =
NULL 

)  const 
Retrieve the given knot value from this surface at the specified V index. Knots are indexed from 0 to numKnots1.
[in]  index  The V index of the knot value to get 
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::setKnotInU  (  unsigned int  index,  
double  param  
) 
Set the value of the given existing knot at the specified U index. Knots are indexed from 0 to numKnots1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.
If a knot value is set that breaks the nondecreasing requirement for the knot array, the knot value will be changed and a kInvalidParameter error will be returned.
[in]  index  The U index of the existing knot to be set 
[out]  param  The new parameter value for the knot 
MStatus MFnNurbsSurface::setKnotInV  (  unsigned int  index,  
double  param  
) 
Set the value of the given existing knot at the specified V index. Knots are indexed from 0 to numKnots1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.
If a knot value is set that breaks the nondecreasing requirement for the knot array, the knot value will be changed and a kInvalidParameter error will be returned.
[in]  index  The V index of the existing knot to be set 
[in]  param  The new value for the knot 
MStatus MFnNurbsSurface::removeKnotInU  (  double  atThisParam,  
bool  removeAll = false 

) 
Remove the U knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.
[in]  atThisParam  Parameter of knot to be removed 
[in]  removeAll  If true then remove all the knots at the given parameter, otherwise remove all except one knot 
MStatus MFnNurbsSurface::removeKnotInV  (  double  atThisParam,  
bool  removeAll = false 

) 
Remove the V knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.
[in]  atThisParam  Parameter of knot to be removed 
[in]  removeAll  If true then remove all the knots at the given parameter, otherwise remove all except one knot 
MStatus MFnNurbsSurface::removeOneKnotInU  (  double  atThisParam  ) 
Remove one U knot at the specified parameter value from this surface.
[in]  atThisParam  Parameter of knot to be removed 
MStatus MFnNurbsSurface::removeOneKnotInV  (  double  atThisParam  ) 
Remove one V knot at the specified parameter value from this surface.
[in]  atThisParam  Parameter of knot to be removed 
MVector MFnNurbsSurface::normal  (  double  paramInU,  
double  paramInV,  
MSpace::Space  space =
MSpace::kObject , 

MStatus *  ReturnStatus =
NULL 

)  const 
Retrieve the normal at the given parameter value on the surface.
[in]  paramInU  U parameter at which to obtain normal 
[in]  paramInV  V parameter at which to obtain normal 
[in]  space  Coordinate space for the returned vector 
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::getTangents  (  double  paramInU,  
double  paramInV,  
MVector &  vectorInU,  
MVector &  vectorInV,  
MSpace::Space  space =
MSpace::kObject 

)  const 
Retrieve the tangents in the U and V directions at the given parameter value on the surface. The returned tangent vectors are normalized.
This method does not fail if the given parameter lies within a trimmed away region of a trimmed surface. Use the 'isPointInTrimmedRegion' method to determine if the uv point lies within such a region.
[in]  paramInU  U parameter value at which to obtain tangents 
[in]  paramInV  V parameter value at which to obtain tangents 
[out]  vectorInU  Storage for the U tangent vector 
[out]  vectorInV  Storage for the V tangent vector 
[in]  space  Coordinate space for the returned vectors 
MStatus MFnNurbsSurface::getDerivativesAtParm  (  double  paramInU,  
double  paramInV,  
MPoint &  pos,  
MVector &  dU,  
MVector &  dV,  
MSpace::Space  space,  
MVector *  dUU = NULL , 

MVector *  dVV = NULL , 

MVector *  dUV = NULL 

)  const 
Evaluate the surface at the given (u,v) coordinate returning position, first derivatives and optionally second derivative information. The returned derivative vectors are not normalized. If either dUU, dVV, or dUV is set to NULL, the second derivatives will not be computed and execution time wil be faster.
[in]  paramInU  U parameter value to evaluate 
[in]  paramInV  V parameter value to evaluate 
[out]  pos  Storage for the XYZ position of (u,v) 
[out]  dU  Storage for the first order partial derivative with respect to u 
[out]  dV  Storage for the first order partial derivative with respect to v 
[in]  space  Coordinate space for the returned vectors 
[out]  dUU  Pointer to storage for the second order partial derivative with respect to u 
[out]  dVV  Pointer to storage for the second order partial derivative with respect to v 
[out]  dUV  Pointer to storage for the second order partial derivative with respect to u then v 
bool MFnNurbsSurface::isFoldedOnBispan  (  )  const 
Evaluate the surface to determine if it contains any folds or creases. The entire surface including trimmed regions is examined. This function will only check for folds on bispan boundaries and thus will not catch all cases.
double MFnNurbsSurface::area  (  double  tolerance =
1.0e3 , 

MStatus *  ReturnStatus =
NULL 

)  const 
Calculates the surface area of this nurbs surface. A value of 0.0 will be returned if the area cannot be determined successfully.
[in]  tolerance  tolerance value to be used for computations 
[out]  ReturnStatus  Status code 
double MFnNurbsSurface::area  (  MSpace::Space  space,  
double  tolerance =
1.0e3 , 

MStatus *  ReturnStatus =
NULL 

)  const 
Calculates the surface area of this nurbs surface in world or local space. A value of 0.0 will be returned if the area cannot be determined successfully.
[in]  space  Coordinate space for the returned vectors 
[in]  tolerance  Tolerance value to be used for computations 
[out]  ReturnStatus  Status code 
MPoint MFnNurbsSurface::closestPoint  (  const MPoint &  toThisPoint,  
double *  paramU = NULL , 

double *  paramV = NULL , 

bool  ignoreTrimBoundaries =
false , 

double  tolerance =
1.0e3 , 

MSpace::Space  space =
MSpace::kObject , 

MStatus *  ReturnStatus =
NULL 

)  const 
Return the closest point on this surface to the given point.
[in]  toThisPoint  Point to be compared. 
[out]  paramU  U parameter value of the closest point. Ignored if null. 
[out]  paramV  V parameter value of the closest point. Ignored if null. 
[in]  ignoreTrimBoundaries  If this is true and the surface is trimmed, look for the point on the entire, untrimmed surface ignoring any trim curves. 
[in]  tolerance  Tolerance value to be used for computations. 
[in]  space  Coordinate space in which perform this operation, 
[out]  ReturnStatus  Status code. 
MPoint MFnNurbsSurface::closestPoint  (  const MPoint &  toThisPoint,  
bool  paramAsStart,  
double *  paramU,  
double *  paramV,  
bool  ignoreTrimBoundaries =
false , 

double  tolerance =
1.0e3 , 

MSpace::Space  space =
MSpace::kObject , 

MStatus *  ReturnStatus =
NULL 

)  const 
Return the closest point on this surface to the given point.
Performance can be greatly increased by supplying a starting parameter value that is reasonably close to the final point and setting 'paramAsStart' to true. However great care must be taken with the use of this parameter and the choice of starting value.
If 'paramAsStart' is true, the algorithm will begin to search for the closest point at the given parameter value, and will check the local surface to see which direction will bring it closer to the given point. It then offsets in this direction and repeats the process, iteratively traversing the surface until it finds the closest point.
This algorithm will fail if it encounters a seam before reaching the closest point, or if it finds a local closest point, such as a bulge on a mesh where an offset in any direction will take it further from the given point, even if that is not the true closest point on the mesh. For this reason it is advisable to avoid using this option unless absolutely sure that the initial point will be a good enough approximation to the final point that these conditions will not occur.
[in]  toThisPoint  Point to be compared 
[in]  paramAsStart  If true use the value pointed to by paramU and paramV as a starting point for the search 
[in,out]  paramU  Returns the U parameter value of the closest point. if 'paramAsStart' is true then the value initially passed in by the caller will be used as the starting U value for the search. Ignored if null. 
[in,out]  paramV  Returns the V parameter value of the closest point. if 'paramAsStart' is true then the value initially passed in by the caller will be used as the starting V value for the search. Ignored if null. 
[in]  ignoreTrimBoundaries  if this is true and the surface is trimmed, look for the point on the entire, untrimmed surface ignoring any trim curves. 
[in]  tolerance  tolerance value to be used for computations 
[in]  space  Coordinate space in which perform this operation 
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::isPointOnSurface  (  const MPoint &  point,  
double  tolerance =
1.0e3 , 

MSpace::Space  space =
MSpace::kObject , 

MStatus *  ReturnStatus =
NULL 

)  const 
Check if the given point is on this surface.
[in]  point  Point to test 
[in]  tolerance  tolerance value to be used for computations 
[in]  space  Coordinate space for this operation 
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::getParamAtPoint  (  const MPoint &  atThisPoint,  
double &  paramU,  
double &  paramV,  
MSpace::Space  space =
MSpace::kObject 

)  const 
This method is obsolete.
MStatus MFnNurbsSurface::getParamAtPoint  (  const MPoint &  atThisPoint,  
double &  paramU,  
double &  paramV,  
bool  ignoreTrimBoundaries,  
MSpace::Space  space =
MSpace::kObject , 

double  tolerance = 1.0e3 

)  const 
Get the parameter value corresponding to the given point on the surface (or underlying surface).
Note, when ignoreTrimBoundaries if false, the UV parameters will still be returned if found on the untrimmed surface even though MS::kFailure is returned. This may be useful in cases where you are walking a trim edge and points are determined to be trimmed away because of slight differences between the trim edge and the actual trimmed surface.
[in]  atThisPoint  Location of parameter to obtain 
[out]  paramU  storage for the U parameter value 
[out]  paramV  storage for the V parameter value 
[in]  ignoreTrimBoundaries  if this is true and the surface is trimmed, look for the param on the entire, untrimmed surface ignoring any trim curves. 
[in]  space  Coordinate space in which to perform this operation 
[in]  tolerance  tolerance used in this operation 
MStatus MFnNurbsSurface::getPointAtParam  (  double  paramU,  
double  paramV,  
MPoint &  point,  
MSpace::Space  space =
MSpace::kObject 

)  const 
Finds the point corresponding to the given parameter value on the surface.
This method does not fail if the given parameter lies within a trimmed away region of a trimmed surface. Use the 'isPointInTrimmedRegion' method to determine if the uv point lies within such a region.
[in]  paramU  U parameter value 
[in]  paramV  V parameter value 
[out]  point  storage for the found point 
[in]  space  Coordinate space in which to perform this operation 
double MFnNurbsSurface::distanceToPoint  (  const MPoint &  pt,  
MSpace::Space  space =
MSpace::kObject , 

MStatus *  ReturnStatus =
NULL 

)  const 
Returns the distance from the given point to the closest point on the surface.
[in]  pt  Point to calculate distance from 
[in]  space  Coordinate space for which to perform operation 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::tesselate  (  MTesselationParams &  parms =
MTesselationParams::fsDefaultTesselationParams , 

MObject  parentOrOwner = MObject::kNullObj , 

MStatus *  ReturnStatus =
NULL 

) 
Performs tesselation on this surface and create a new mesh in the DAG. The type of tesselation can be controlled by providing the tesselation parameters (see MTesselationParams).
The parentOrOwner argument is used to specify the owner of the new surface.
If the parentOrOwner is kMeshData then the created surface will be of type kMeshGeom and will be returned. The parentOrOwner will become the owner of the new mesh.
If parentOrOwner is NULL then a new transform will be created and returned which will be the parent for the mesh. The new transform will be added to the DAG.
If parentOrOwner is a DAG node then the new mesh will be returned and the parentOrOwner will become its parent.
[in]  parms  Tesselation parameters 
[in]  parentOrOwner  the DAG parent or kMeshData the new mesh will belong to 
[out]  ReturnStatus  Status code 
bool MFnNurbsSurface::intersect  (  const MPoint &  rayStartingPoint,  
const MVector &  alongThisDirection,  
double &  u,  
double &  v,  
MPoint &  pntOfIntersection,  
double  tolerance =
1.0e3 , 

MSpace::Space  space =
MSpace::kObject , 

bool  calculateDistance =
false , 

double *  distance = NULL , 

bool  calculateExactHit =
false , 

bool *  wasExactHit =
NULL , 

MStatus *  ReturnStatus =
NULL 

)  const 
This function determines the closest point of intersection of this spline surface with a ray (a vector at a point).
[in]  rayStartingPoint  Starting location of ray to test. 
[in]  alongThisDirection  Direction of ray to test. 
[out]  u  U parameter of intersection (if any). 
[out]  v  V parameter of intersection (if any). 
[out]  pntOfIntersection  Closest point of intersection (if any). 
[in]  tolerance  The epsilon value in the calculation. 
[in]  space  Specifies the coordinate system for this operation. 
[in]  calculateDistance  Specifies whether to calculate the distance of the startPoint to the point of intersection 
[out]  distance  Distance of intersection point from startPoint. Ignored if 'calculateDistance' is false. 
[in]  calculateExactHit  Specifies whether to determine if the point of intersection actually hit the object or just came within tolerance of it. 
[out]  wasExactHit  Returns true if the point of intersection is an exact hit, false otherwise. Ignored if 'calculateExactHit' if false. 
[out]  ReturnStatus  Status code. 
bool MFnNurbsSurface::intersect  (  const MPoint &  rayStartingPoint,  
const MVector &  alongThisDirection,  
MDoubleArray &  uArray,  
MDoubleArray &  vArray,  
MPointArray &  points,  
double  tolerance =
1.0e3 , 

MSpace::Space  space =
MSpace::kObject , 

bool  calculateDistance =
false , 

MDoubleArray *  distances = NULL , 

bool  calculateExactHit =
false , 

bool *  wasExactHit =
NULL , 

MStatus *  ReturnStatus =
NULL 

)  const 
This function determines all the points of intersection of this spline surface with a ray (a vector at a point).
[in]  rayStartingPoint  Starting location of ray to test. 
[in]  alongThisDirection  Direction of ray to test. 
[out]  uArray  U parameters of intersections. 
[out]  vArray  V parameters of intersections. 
[out]  points  Points of intersection. 
[in]  tolerance  The epsilon value in the calculation. 
[in]  space  Specifies the coordinate system for this operation. 
[in]  calculateDistance  Specifies whether to calculate the distances of the startPoint to the all the points of intersection. 
[out]  distances  Distances of intersection points from startPoint. Ignored if 'calculateDistance' is false. 
[in]  calculateExactHit  Specifies whether to determine if the point of intersection actually hit the object or just came within tolerance of it. 
[out]  wasExactHit  Returns true if the point of intersection is an exact hit, false otherwise. Ignored if 'calculateExactHit' if false. 
[out]  ReturnStatus  Status code. 
bool MFnNurbsSurface::hasHistoryOnCreate  (  MStatus *  ReturnStatus =
NULL 
) 
This method determines if the shape was created with history.
If the object that this function set is attached to is not a shape then this method will fail.
[out]  ReturnStatus 
MStatus MFnNurbsSurface::updateSurface  (  ) 
This method signals that this surface has changed and needs to be recalculated.
This method is useful when a large number of CVs for the surface are being modified. Instead of updating the surface every time a CV is changed it is more efficient to call this method once after updating all of the CVs.
bool MFnNurbsSurface::isTrimmedSurface  (  MStatus *  ReturnStatus =
NULL 
) 
This method determines if this surface is a trimmed surface.
[out]  ReturnStatus 
unsigned int MFnNurbsSurface::numRegions  (  MStatus *  ReturnStatus =
NULL 
) 
Returns the number of trimmed regions for this surface or 0 if the surface is not a trimmed surface.
For each region there may be several boundary curves, an outer curve and possibly several inner boundary curves which define holes. These boundary curves are made up of one or more curves called edges.
[out]  ReturnStatus 
bool MFnNurbsSurface::isFlipNorm  (  unsigned int  region,  
MStatus *  ReturnStatus =
NULL 

) 
Determines whether the normal for the specified region is flipped. This method is only valid for trimmed surfaces.
[out]  ReturnStatus  Status code 
unsigned int MFnNurbsSurface::numBoundaries  (  unsigned int  region,  
MStatus *  ReturnStatus =
NULL 

) 
Returns the number of boudaries for the specified region. The surface must be a trimmed surface.
For each region there may be several boundary curves, an outer curve and possibly several inner boundary curves which define holes. These boundary curves are made up of one or more curves called edges.
[in]  region  The trimmed region to examine 
[out]  ReturnStatus  status code 
MFnNurbsSurface::BoundaryType MFnNurbsSurface::boundaryType  (  unsigned int  region,  
unsigned int  boundary,  
MStatus *  ReturnStatus =
NULL 

) 
Returns the type of the specified boundary. The surface must be a trimmed surface.
Possible boundary types are Inner, kOuter, kSegment, kClosedSegment, and kInvalidBoundary
[in]  region  the region to examine 
[in]  boundary  the boundary to examine 
[out]  ReturnStatus  status code 
unsigned int MFnNurbsSurface::numEdges  (  unsigned int  region,  
unsigned int  boundary,  
MStatus *  ReturnStatus =
NULL 

) 
Return the number of edges for the specified trim boundary.
For each region there may be several boundary curves, an outer curve and possibly several inner boundary curves which define holes. These boundary curves are made up of one or more curves called edges.
[in]  region  Region to examine 
[in]  boundary  Boundary to examine 
[out]  ReturnStatus  Status code 
MObjectArray MFnNurbsSurface::edge  (  unsigned int  region,  
unsigned int  boundary,  
unsigned int  edge,  
bool  paramEdge = false , 

MStatus *  ReturnStatus =
NULL 

) 
Return the specified edge of a trim boundary.
For each region of a trimmed surface there may be several boundary curves; an outer curve and possibly several inner boundary curves (which define holes). These boundary curves are made up of one or more curves called edges. The edge is returned as an MObjectArray as the edge may consist of more than one curve. The returned edge, or trim curve, can be a 2D parameter edge or a 3D edge curve. To identify an edge you must specify the trimmed region, the boundary of that region, and the edge of that boundary.
Note that for closed surfaces some of the 3d edges may be 0 length in which case an empty MObjectArray is returned. An example of this is the poles of a sphere.
[in]  region  the trimmed region containing the edge 
[in]  boundary  the boundary to examine 
[in]  edge  the boundary edge to examine 
[in]  paramEdge  if true then 2D param edges are returned, otherwise a 3D edge is returned. 
[out]  ReturnStatus  status code 
bool MFnNurbsSurface::isPointInTrimmedRegion  (  double  u,  
double  v,  
MStatus *  ReturnStatus =
NULL 

) 
Returns true if the given point is in a trimmed away region of a trimmed surface. A trimmed away region is the part of the surface that is cut away as a result of a trim operation.
[in]  u  u parameter of point on surface to test 
[in]  v  v parameter of point on surface to test 
[out]  ReturnStatus  status code 
MStatus MFnNurbsSurface::getTrimBoundaries  (  MTrimBoundaryArray &  result,  
unsigned int  region,  
bool  paramEdge = true 

) 
Returns all trim boundaries of a region on this surface.
[out]  result  All trim boundaries of the given region in this surface. 
[in]  region  the trimmed region that containing the boundaries 
[in]  paramEdge  If true, then 2D curves are returned, otherwise 3D curves. 
MStatus MFnNurbsSurface::trimWithBoundaries  (  const MTrimBoundaryArray &  mBoundaries,  
bool  flipNormal =
false , 

double  e_tol = 1e3 , 

double  pe_tol = 1e5 

) 
This function trims this surface with given trim boundaries.
NOTE: The curves specified in the MTrimBoundaryArray are in UV space. As a result, they must be 2D curves. The MFnNurbsCurve functionset provides a method for creating 2D curves.
[in]  mBoundaries  The boundaries used for the trim. A boundary may consist of several curves. They must present a closed boundary, must be in UV (parameter) space, and must be on the surface. Boundaries[0] is the outer boundary which goes counterclockwise around the surface normal. All other boundaries must be inner boundaries inside the outer boundary defined region. If an inner boundary goes clockwise, it defines a hole, otherwise it should define an island inside a hole. Boundaries[0] can be empty. In this case, the native boundary is used as outer boundary. The boundaries should not intersect to each other or to itself. 
[in]  flipNormal  Whether to flip the trimmed surface normal 
[in]  e_tol  The 3d edge tolerance with which to trim 
[in]  pe_tol  The parameter edge tolerance with which to trim 
MStatus MFnNurbsSurface::projectCurve  (  MDagPath &  curve,  
MVector *  direction = NULL , 

bool  constructionHistory =
false 

) 
Project the given curve onto this surface creating a curve on surface. Projection will be done using the surface normals unless a direction vector to project along is given.
[in]  curve  curve to be projected 
[in]  direction  direction of projection. If this is null then the surface normals is used 
[in]  constructionHistory  keep construction history 
MStatus MFnNurbsSurface::trim  (  MDoubleArray &  locatorU,  
MDoubleArray &  locatorV,  
bool  constructionHistory =
false 

) 
Trim this surface to its curves on surface. Regions which are kept are specified by passing in two arrays of u,v parameters.
This method will create a new trimmed surface in the DAG. The surface attached to this function set will remain unchanged.
[in]  locatorU  array of U parameters indicating regions to keep 
[in]  locatorV  array of V parameters indicating regions to keep 
[in]  constructionHistory  keep construction history 
unsigned int MFnNurbsSurface::numPatches  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of nonzero patches in this surface.
[out]  ReturnStatus  Status code 
unsigned int MFnNurbsSurface::numPatchesInU  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of nonzero patches along u, in this surface.
[out]  ReturnStatus  Status code 
unsigned int MFnNurbsSurface::numPatchesInV  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of nonzero patches along v, in this surface.
[out]  ReturnStatus  Status code 
int MFnNurbsSurface::numUVs  (  MStatus *  ReturnStatus =
NULL 
)  const 
Returns the number of texture (uv) coordinates for this surface. The uv's are stored in a list which is referenced by patches requiring textures on a perpatch perpatchCorner basis. This method returns the number of elements in this list.
[out]  ReturnStatus  Status code 
MStatus MFnNurbsSurface::setUVs  (  const MFloatArray &  uArray,  
const MFloatArray &  vArray  
) 
Sets all of the texture coordinates (uvs) for this surface. The uv arrays must be of equal size and must be at least of length numUVs(). If the arrays are larger than numUVs() then the uv list for this surface will be grown to accommodate the new uv values.
After using this method to set the UV values, you can call assignUVs to assign the corresponding UVids to the geometry.
Also, note that API methods that modify uv data, work correctly either when called through a plugin node that is in the history of the shape, or when used on a surface shape that does not have history. Modifying uvs directly on a shape with history will result in the modifications getting overwritten by the next evaluation of the history attached to the shape.
[in]  uArray  The array of u values to be set 
[in]  vArray  The array of v values to be set 
MStatus MFnNurbsSurface::getUVs  (  MFloatArray &  uArray,  
MFloatArray &  vArray  
)  const 
This method copies the texture coordinate list for this surface into the given uv arrays.
[out]  uArray  Storage for the u texture coordinate list 
[out]  vArray  Storage for the v texture coordinate list 
MStatus MFnNurbsSurface::setUV  (  int  uvId,  
float  u,  
float  v  
) 
Sets the specified texture coordinate. The uvId is the element in the uv list that will be set. If the uvId is greater than or equal to numUVs() then the uv list will be grown to accommodate the specified uv.
Also, note that API methods that modify uv data, work correctly either when called through a plugin node that is in the history of the shape, or when used on a surface shape that does not have history. Modifying uvs directly on a shape with history will result in the modifications getting overwritten by the next evaluation of the history attached to the shape.
[in]  uvId  the element in the uv list to be set 
[in]  u  the new u value that is to be set 
[in]  v  the new v value that is to be set 
MStatus MFnNurbsSurface::getUV  (  int  uvId,  
float &  u,  
float &  v  
)  const 
Get the value of the specified texture coordinate from this surface's uv list. The uvId is the element in the uv list that will be retrieved.
[in]  uvId  the element in the uv list to examine 
[out]  u  storage for the u value 
[out]  v  storage for the v value 
MStatus MFnNurbsSurface::getPatchUV  (  int  patchId,  
int  cornerIndex,  
float &  u,  
float &  v  
)  const 
Get the value of the specified texture coordinate for a patch corner in a patch. Since texture coordinates (uv's) are stored perpatch percorner you must specify both the patch and the corner that the u and v values are mapped to.
[in]  patchId  The patch to examine 
[in]  cornerIndex  The patchrelative corner to examine 
[out]  u  storage for the u value 
[out]  v  storage for the v value 
MStatus MFnNurbsSurface::getPatchUVs  (  int  patchId,  
MFloatArray &  uArray,  
MFloatArray &  vArray  
)  const 
Get the values of the texture coordinate on a specified patch. Since texture coordinates (uvs) are stored perpatch percorner, the u and v values mapped to all corners of the specified patch are returned.
[in]  patchId  The patch to examine 
[out]  uArray  storage for u values 
[out]  vArray  storage for v values 
MStatus MFnNurbsSurface::getPatchUVid  (  int  patchId,  
int  cornerIndex,  
int &  uvId  
)  const 
Get the id of the specified texture coordinate for a corner in a patch.
[in]  patchId  The patch to examine 
[in]  cornerIndex  The patchrelative corner to examine (local index) 
[out]  uvId  storage for the uv index 
MStatus MFnNurbsSurface::assignUV  (  int  patchId,  
int  cornerIndex,  
int  uvId  
) 
Maps a texture coordinate to a the specified corner of a patch.
Since texture coordinates (uvs) are stored perpatch perpatchCorner you must specify both the patch and the patchCorner that the uv entry is mapped to.
The cornerIndex is the corner within the patch that the uv will be mapped to. This index must be in the range 0 to patchCornerCount(patchId).
Also, note that API methods that modify uv data, work correctly either when called through a plugin node that is in the history of the shape, or when used on a surface shape that does not have history. Modifying uvs directly on a shape with history will result in the modifications getting overwritten by the next evaluation of the history attached to the shape.
[in]  patchId  The patch to map to 
[in]  cornerIndex  The corner of the patch to map to 
[in]  uvId  The uv entry from the uv list that will be mapped 
This method maps all texture coordinates for the surface. The setUV/setUVs method is used to create the texture coordinate table for the surface. After the table is created, this method is used to map those values to each patch on a percorner basis. The setUV/setUVs method should be called before the assignUVs method.
The uvCounts array should contain the number of uvs per patch. Since uvs are mapped perpatch percorner, the entries in this array should match the corner counts for each patch in the surface.
If an entry in this array is '0' then the corresponding patch will not be mapped. The sum of all the entries in the uvCounts array must be equal to the size of the uvIds array or this method will fail.
The uvIds array should contain the UV indices that will be mapped to each patchcorner in the surface. The entries in this array specify which uvs in the surface's uv table are mapped to each patchcorner. Each entry in the uvIds array must be less than numUVs(). The size of the uvIds array is equivalent to adding up all of the entries in the uvCounts array, so for a cube with all patches mapped there would be 24 entries.
Also, note that API methods that modify uv data, work correctly either when called through a plugin node that is in the history of the shape, or when used on a surface shape that does not have history. Modifying uvs directly on a shape with history will result in the modifications getting overwritten by the next evaluation of the history attached to the shape.
[in]  uvCounts  The uv counts for each patch in the surface 
[in]  uvIds  The uv indices to be mapped to each patchcorner 
MStatus MFnNurbsSurface::clearUVs  (  ) 
This method clears out all texture coordinates for the nurbsSurface, and leaves behind an empty UVset.
This method should be used if it is needed to shrink the actual size of the UV table. In this case, the user should call clearUVs, setUVs and then assignUVs to rebuild the mapping info.
When called on a dataNurbsSurface, the UVs are removed. When called on a shape with no history, the UVs are removed and the attributes are set on the shape. When called on a shape with history, the polyDelMap command is invoked and a polyMapDel node is created.
Get assigned UVs. This method finds all texture coordinates for the surface that have been mapped, and returns them in the same format as assignUVs. The setUV/setUVs method is used to create the texture coordinate table for the surface and this method is used to map those values to each patch on a percorner basis.
The uvCounts array should contain the number of uv's per patch. Since uvs are mapped perpatch percorner, the entries returned in this array will match the corner counts for each patch in the surface. For example, suppose that we have a cube with 2 of the faces mapped: the array for this cube would be { 4, 4, 0, 0, 0, 0 } since there are 6 patches each with 4 vertices. A face either has all its vertives mapped, or none
The uvIds array will contain the UV indices that will be mapped to each patchcorner in the surface. Use the getUV method to get the actual uv values for these id's.
[out]  uvCounts  The uv counts for each patch in the surface 
[out]  uvIds  The uv indices to be mapped to each patchcorner 
MObject MFnNurbsSurface::tesselate  (  MTesselationParams &  parms,  
MStatus *  ReturnStatus  
) 
This method is obsolete.
Performs tesselation on this surface and returns the tesselated polygonal object. The type of tesselation can be controlled by providing the tesselation parameters (see MTesselationParams).[in]  parms  Tesselation parameters 
[out]  ReturnStatus  Status code 
MObject MFnNurbsSurface::getDataObject  (  )  const 
Returns an MObject if the class has been constructed with an MFn::kNurbsSurfaceData entity, otherwise MObject::kNullObj is returned.
Autodesk® Maya® 2011 © 19972010 Autodesk, Inc. All rights reserved.  Generated with 1.5.6 