11 import sys, math, ctypes, collections
12 import maya.api.OpenMaya
as om
13 import maya.api.OpenMayaUI
as omui
14 import maya.api.OpenMayaRender
as omr
18 The presence of this function tells Maya that the plugin produces, and
19 expects to be passed, objects created using the Maya Python API 2.0.
24 def useSelectHighlight(selectedList, path):
26 displayStatus = omr.MGeometryUtilities.displayStatus(path)
27 if displayStatus == omr.MGeometryUtilities.kHilite
or displayStatus == omr.MGeometryUtilities.kActiveComponent:
30 pathCopy = om.MDagPath(path)
32 while pathCopy.length() > 0:
33 if selectedList.hasItem(pathCopy):
39 def floatApproxEqual(left, right):
40 return abs(left - right) < 0.0001
49 def __init__(self, other=None):
56 return self.faceVertexIndex[fvi]
58 def getUV(self, uvId):
59 return [ self.ucoord[uvId], self.vcoord[uvId] ]
62 return self.ucoord[uvId]
65 return self.vcoord[uvId]
68 return len(self.ucoord)
70 def append_uv(self, u, v):
71 self.ucoord.append( u )
72 self.vcoord.append( v )
75 self.ucoord = om.MFloatArray()
76 self.vcoord = om.MFloatArray()
77 self.faceVertexIndex = om.MIntArray()
79 def copy(self, other):
80 self.ucoord = om.MFloatArray(other.ucoord)
81 self.vcoord = om.MFloatArray(other.vcoord)
82 self.faceVertexIndex = om.MIntArray(other.faceVertexIndex)
86 self.vertices = om.MPointArray()
87 self.face_counts = om.MIntArray()
88 self.face_connects = om.MIntArray()
89 self.normals = om.MVectorArray()
90 self.uvcoords = apiMeshGeomUV()
93 def copy(self, other):
94 self.vertices = om.MPointArray(other.vertices)
95 self.face_counts = om.MIntArray(other.face_counts)
96 self.face_connects = om.MIntArray(other.face_connects)
97 self.normals = om.MVectorArray(other.normals)
98 self.uvcoords = apiMeshGeomUV(other.uvcoords)
99 self.faceCount = other.faceCount
117 kWrapString =
"\n\t\t"
119 kNormalKeyword =
"vn"
120 kTextureKeyword =
"vt"
121 kFaceKeyword =
"face"
124 class apiMeshGeomIterator(om.MPxGeometryIterator):
125 def __init__(self, userGeometry, components):
126 om.MPxGeometryIterator.__init__(self, userGeometry, components)
127 self.geometry = userGeometry
134 om.MPxGeometryIterator.reset(self)
135 self.currentPoint = 0
137 maxVertex = len(self.geometry.vertices)
138 self.maxPoints = maxVertex
147 pnt = self.geometry.vertices[ self.index() ]
150 def setPoint(self, pnt):
155 self.geometry.vertices[ self.index() ] = pnt
157 def iteratorCount(self):
162 return len(self.geometry.vertices)
170 class apiMeshData(om.MPxGeometryData):
171 typeName =
"apiMeshData"
172 id = om.MTypeId(0x80777)
179 om.MPxGeometryData.__init__(self)
180 self.fGeometry = apiMeshGeom()
183 self.fGeometry =
None
185 def readASCII(self, argList, idx):
186 idx = self.readVerticesASCII(argList, idx)
187 idx = self.readNormalsASCII(argList, idx)
188 idx = self.readFacesASCII(argList, idx)
189 idx = self.readUVASCII(argList, idx)
192 def readBinary(self, inputData, length):
196 def writeASCII(self):
197 data = self.writeVerticesASCII()
198 data += self.writeNormalsASCII()
199 data += self.writeFacesASCII()
200 data += writeUVASCII()
203 def writeBinary(self):
208 self.fGeometry.copy(src.fGeometry)
211 return apiMeshData.id
214 return apiMeshData.typeName
222 def iterator(self, componentList, component, useComponents, world=None):
224 return apiMeshGeomIterator(self.fGeometry, componentList)
226 return apiMeshGeomIterator(self.fGeometry, component)
234 def readVerticesASCII(self, argList, idx):
237 geomStr = argList.asString(idx)
242 if geomStr == kVertexKeyword:
243 idx = argList.lastArgUsed()+1
244 vertexCount = argList.asInt(idx)
245 idx = argList.lastArgUsed()+1
246 for i
in xrange(vertexCount):
247 vertex = argList.asPoint(idx)
248 idx = argList.lastArgUsed()+1
249 self.fGeometry.vertices.append(vertex)
253 def readNormalsASCII(self, argList, idx):
256 geomStr = argList.asString(idx)
261 if geomStr == kNormalKeyword:
262 idx = argList.lastArgUsed()+1
263 normalCount = argList.asInt(idx)
264 idx = argList.lastArgUsed()+1
265 for i
in xrange(normalCount):
266 normal = argList.asVector(idx)
267 idx = argList.lastArgUsed()+1
268 self.fGeometry.normals.append(normal)
272 def readFacesASCII(self, argList, idx):
275 geomStr = argList.asString(idx)
280 while geomStr == kFaceKeyword:
281 idx = argList.lastArgUsed()+1
282 faceCount = argList.asInt(idx)
283 idx = argList.lastArgUsed()+1
284 self.fGeometry.face_counts.append(faceCount)
285 for i
in xrange(faceCount):
286 vid = argList.asInt(idx)
287 idx = argList.lastArgUsed()+1
288 self.fGeometry.face_connects.append(vid)
291 geomStr = argList.asString(idx)
296 self.fGeometry.faceCount = len(self.fGeometry.face_counts)
299 def readUVASCII(self, argList, idx):
300 self.fGeometry.uvcoords.reset()
304 geomStr = argList.asString(idx)
309 if geomStr == kUVKeyword:
310 idx = argList.lastArgUsed()+1
311 uvCount = argList.asInt(idx)
312 idx = argList.lastArgUsed()+1
313 faceVertexListCount = argList.asInt(idx)
314 idx = argList.lastArgUsed()+1
315 for i
in xrange(uvCount):
316 u = argList.asDouble(idx)
317 idx = argList.lastArgUsed()+1
318 v = argList.asDouble(idx)
319 idx = argList.lastArgUsed()+1
320 self.fGeometry.uvcoords.append_uv(u, v)
322 for i
in xrange(faceVertexListCount):
323 fvi = argList.asInt(idx)
324 idx = argList.lastArgUsed()+1
325 self.fGeometry.uvcoords.faceVertexIndex.append( fvi )
329 def writeVerticesASCII(self):
330 vertexCount = len(self.fGeometry.vertices)
334 data += kDblQteChar + kVertexKeyword + kDblQteChar + kSpaceChar + str(vertexCount)
336 for i
in xrange(vertexCount):
337 vertex = self.fGeometry.vertices[i]
340 data += str(vertex[0]) + kSpaceChar + str(vertex[1]) + kSpaceChar + str(vertex[2])
344 def writeNormalsASCII(self):
345 normalCount = len(self.fGeometry.normals)
349 data += kDblQteChar + kNormalKeyword + kDblQteChar + kSpaceChar + str(normalCount)
351 for i
in xrange(normalCount):
352 normal = self.fGeometry.normals[i]
355 data += str(normal[0]) + kSpaceChar + str(normal[1]) + kSpaceChar + str(normal[2])
359 def writeFacesASCII(self):
360 numFaces = len(self.fGeometry.face_counts)
365 for i
in xrange(numFaces):
366 faceVertexCount = self.fGeometry.face_counts[i]
370 data += kDblQteChar + kFaceKeyword + kDblQteChar + kSpaceChar + str(faceVertexCount)
374 for v
in xrange(faceVertexCount):
375 value = self.fGeometry.face_connects[vid]
377 data += str(value) + kSpaceChar
382 def writeUVASCII(self):
383 uvCount = self.fGeometry.uvcoords.uvcount()
384 faceVertexCount = len(self.fGeometry.uvcoords.faceVertexIndex)
391 data += kDblQteChar + kUVKeyword + kDblQteChar + kSpaceChar + str(uvCount) + kSpaceChar + str(faceVertexCount)
393 for i
in xrange(uvCount):
394 uv = self.fGeometry.uvcoords.getUV(i)
397 data += uv[0] + kSpaceChar + uv[1] + kSpaceChar
399 for i
in xrange(faceVertexCount):
400 value = self.fGeometry.uvcoords.faceVertexIndex[i]
403 data += value + kSpaceChar
427 class apiMesh(om.MPxSurfaceShape):
428 id = om.MTypeId(0x80099)
439 useWeightedTransformUsingFunction =
None
440 useWeightedTweakUsingFunction =
None
457 typedAttr = om.MFnTypedAttribute()
458 numericAttr = om.MFnNumericAttribute()
461 apiMesh.inputSurface = typedAttr.create(
"inputSurface",
"is", apiMeshData.id, om.MObject.kNullObj )
462 typedAttr.storable =
False
463 om.MPxNode.addAttribute( apiMesh.inputSurface )
465 apiMesh.useWeightedTransformUsingFunction = numericAttr.create(
"useWeightedTransformUsingFunction",
"utru", om.MFnNumericData.kBoolean,
True )
466 numericAttr.keyable =
True
467 om.MPxNode.addAttribute( apiMesh.useWeightedTransformUsingFunction )
469 apiMesh.useWeightedTweakUsingFunction = numericAttr.create(
"useWeightedTweakUsingFunction",
"utwu", om.MFnNumericData.kBoolean,
True )
470 numericAttr.keyable =
True
471 om.MPxNode.addAttribute( apiMesh.useWeightedTweakUsingFunction )
477 apiMesh.bboxCorner1 = numericAttr.create(
"bboxCorner1",
"bb1", om.MFnNumericData.k3Double, 0 )
478 numericAttr.array =
False
479 numericAttr.usesArrayDataBuilder =
False
480 numericAttr.hidden =
False
481 numericAttr.keyable =
False
482 om.MPxNode.addAttribute( apiMesh.bboxCorner1 )
484 apiMesh.bboxCorner2 = numericAttr.create(
"bboxCorner2",
"bb2", om.MFnNumericData.k3Double, 0 )
485 numericAttr.array =
False
486 numericAttr.usesArrayDataBuilder =
False
487 numericAttr.hidden =
False
488 numericAttr.keyable =
False
489 om.MPxNode.addAttribute( apiMesh.bboxCorner2 )
493 apiMesh.outputSurface = typedAttr.create(
"outputSurface",
"os", apiMeshData.id, om.MObject.kNullObj )
494 typedAttr.writable =
False
495 om.MPxNode.addAttribute( apiMesh.outputSurface )
497 apiMesh.worldSurface = typedAttr.create(
"worldSurface",
"ws", apiMeshData.id, om.MObject.kNullObj )
498 typedAttr.cached =
False
499 typedAttr.writable =
False
500 typedAttr.array =
True
501 typedAttr.usesArrayDataBuilder =
True
502 typedAttr.disconnectBehavior = om.MFnAttribute.kDelete
503 typedAttr.worldSpace =
True
504 om.MPxNode.addAttribute( apiMesh.worldSurface )
508 apiMesh.cachedSurface = typedAttr.create(
"cachedSurface",
"cs", apiMeshData.id, om.MObject.kNullObj )
509 typedAttr.readable =
True
510 typedAttr.writable =
True
511 typedAttr.storable =
True
512 om.MPxNode.addAttribute( apiMesh.cachedSurface )
516 om.MPxNode.attributeAffects( apiMesh.inputSurface, apiMesh.outputSurface )
517 om.MPxNode.attributeAffects( apiMesh.inputSurface, apiMesh.worldSurface )
518 om.MPxNode.attributeAffects( apiMesh.outputSurface, apiMesh.worldSurface )
519 om.MPxNode.attributeAffects( apiMesh.inputSurface, apiMesh.bboxCorner1 )
520 om.MPxNode.attributeAffects( apiMesh.inputSurface, apiMesh.bboxCorner2 )
521 om.MPxNode.attributeAffects( apiMesh.cachedSurface, apiMesh.outputSurface )
522 om.MPxNode.attributeAffects( apiMesh.cachedSurface, apiMesh.worldSurface )
524 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlPoints, apiMesh.outputSurface )
525 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueX, apiMesh.outputSurface )
526 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueY, apiMesh.outputSurface )
527 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueZ, apiMesh.outputSurface )
528 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlPoints, apiMesh.cachedSurface )
529 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueX, apiMesh.cachedSurface )
530 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueY, apiMesh.cachedSurface )
531 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueZ, apiMesh.cachedSurface )
532 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlPoints, apiMesh.worldSurface )
533 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueX, apiMesh.worldSurface )
534 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueY, apiMesh.worldSurface )
535 om.MPxNode.attributeAffects( om.MPxSurfaceShape.mControlValueZ, apiMesh.worldSurface )
538 om.MPxSurfaceShape.__init__(self)
548 def postConstructor(self):
563 self.isRenderable =
True
567 self.fHasHistoryOnCreate =
False
571 self.fShapeDirty =
True
572 self.fMaterialDirty =
True
574 def compute(self, plug, datablock):
587 if plug == apiMesh.outputSurface:
588 return self.computeOutputSurface( plug, datablock )
590 elif plug == apiMesh.cachedSurface:
591 return self.computeOutputSurface( plug, datablock )
593 elif plug == apiMesh.worldSurface:
594 return self.computeWorldSurface( plug, datablock )
600 def preEvaluation(self, context, evaluationNode):
612 if context.isNormal():
613 if evaluationNode.dirtyPlugExists(apiMesh.inputSurface)
or evaluationNode.dirtyPlugExists(apiMesh.mControlPoints):
616 def postEvaluation(self, context, evaluationNode, evalType):
629 if context.isNormal():
630 if evaluationNode.dirtyPlugExists(apiMesh.inputSurface)
or evaluationNode.dirtyPlugExists(apiMesh.mControlPoints):
631 self.notifyViewport()
633 def setDependentsDirty(self, plug, plugArray):
645 if plug == apiMesh.inputSurface
or plug == om.MPxSurfaceShape.mControlPoints
or plug == om.MPxSurfaceShape.mControlValueX
or plug == om.MPxSurfaceShape.mControlValueY
or plug == om.MPxSurfaceShape.mControlValueZ:
646 self.signalDirtyToViewport()
648 def getInternalValue(self, plug, handle):
674 if plug == om.MPxSurfaceShape.mControlPoints
or plug == om.MPxSurfaceShape.mControlValueX
or plug == om.MPxSurfaceShape.mControlValueY
or plug == om.MPxSurfaceShape.mControlValueZ:
682 if self.hasHistory():
683 return om.MPxNode.getInternalValue(self, plug, handle)
686 if plug == om.MPxSurfaceShape.mControlPoints
and not plug.isArray():
687 index = plug.logicalIndex()
688 pnt = self.getPointValue(index)
689 handle.set3Double( pnt[0], pnt[1], pnt[2] )
691 elif plug == om.MPxSurfaceShape.mControlValueX:
692 parentPlug = plug.parent()
693 index = parentPlug.logicalIndex()
694 val = self.getChannelValue( index, 0 )
695 handle.setDouble( val )
697 elif plug == om.MPxSurfaceShape.mControlValueY:
698 parentPlug = plug.parent()
699 index = parentPlug.logicalIndex()
700 val = self.getChannelValue( index, 1 )
701 handle.setDouble( val )
703 elif plug == om.MPxSurfaceShape.mControlValueZ:
704 parentPlug = plug.parent()
705 index = parentPlug.logicalIndex()
706 val = self.getChannelValue( index, 2 )
707 handle.setDouble( val )
716 elif plug == om.MPxSurfaceShape.mHasHistoryOnCreate:
717 handle.setBool( self.fHasHistoryOnCreate )
720 isOk = om.MPxSurfaceShape.getInternalValue(self, plug, handle)
724 def setInternalValue(self, plug, handle):
750 if plug == om.MPxSurfaceShape.mControlPoints
or plug == om.MPxSurfaceShape.mControlValueX
or plug == om.MPxSurfaceShape.mControlValueY
or plug == om.MPxSurfaceShape.mControlValueZ:
760 if self.hasHistory():
761 self.verticesUpdated()
762 return om.MPxNode.setInternalValue(self, plug, handle)
765 if plug == om.MPxSurfaceShape.mControlPoints
and not plug.isArray():
766 index = plug.logicalIndex()
767 self.setPointValue( index, handle.asDouble3() )
769 elif plug == om.MPxSurfaceShape.mControlValueX:
770 parentPlug = plug.parent()
771 index = parentPlug.logicalIndex()
772 self.setChannelValue( index, 0, handle.asDouble() )
774 elif plug == om.MPxSurfaceShape.mControlValueY:
775 parentPlug = plug.parent()
776 index = parentPlug.logicalIndex()
777 self.setChannelValue( index, 1, handle.asDouble() )
779 elif plug == om.MPxSurfaceShape.mControlValueZ:
780 parentPlug = plug.parent()
781 index = parentPlug.logicalIndex()
782 self.setChannelValue( index, 2, handle.asDouble() )
791 elif plug == om.MPxSurfaceShape.mHasHistoryOnCreate:
792 self.fHasHistoryOnCreate = handle.asBool()
795 isOk = om.MPxSurfaceShape.setInternalValue(self, plug, handle)
799 def connectionMade(self, plug, otherPlug, asSrc):
807 if plug == apiMesh.inputSurface:
808 thisObj = self.thisMObject()
809 historyPlug = om.MPlug( thisObj, om.MPxSurfaceShape.mHasHistoryOnCreate )
810 historyPlug.setBool(
True )
812 thisObj = self.thisMObject()
813 dgNode = om.MFnDependencyNode( thisObj )
814 instObjGroups = dgNode.findPlug(
"instObjGroups",
True)
815 if plug == instObjGroups:
816 self.setMaterialDirty(
True)
818 return om.MPxNode.connectionMade(self, plug, otherPlug, asSrc )
820 def connectionBroken(self, plug, otherPlug, asSrc):
828 if plug == apiMesh.inputSurface:
829 thisObj = self.thisMObject()
830 historyPlug = om.MPlug( thisObj, om.MPxSurfaceShape.mHasHistoryOnCreate )
831 historyPlug.setBool(
False )
833 thisObj = self.thisMObject()
834 dgNode = om.MFnDependencyNode( thisObj )
835 instObjGroups = dgNode.findPlug(
"instObjGroups",
True)
836 if plug == instObjGroups:
837 self.setMaterialDirty(
True)
839 return om.MPxNode.connectionBroken(self, plug, otherPlug, asSrc )
841 def shouldSave(self, plug):
852 if plug == om.MPxSurfaceShape.mControlPoints
or plug == om.MPxSurfaceShape.mControlValueX
or plug == om.MPxSurfaceShape.mControlValueY
or plug == om.MPxSurfaceShape.mControlValueZ:
853 if self.hasHistory():
857 result = om.MPxNode.shouldSave(self, plug)
862 elif plug == apiMesh.cachedSurface:
863 if self.hasHistory():
867 data = plug.asMObject()
868 result =
not data.isNull()
871 result = om.MPxNode.shouldSave(self, plug)
877 def componentToPlugs(self, component, list):
890 if component.hasFn(om.MFn.kSingleIndexedComponent):
891 fnVtxComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(component) )
892 thisNode = self.thisMObject()
893 plug = om.MPlug( thisNode, om.MPxSurfaceShape.mControlPoints )
897 self.convertToTweakNodePlug(plug)
899 for i
in xrange(fnVtxComp.elementCount):
900 plug.selectAncestorLogicalIndex(fnVtxComp.element(i), plug.attribute())
903 def matchComponent(self, item, spec, list):
927 result = om.MPxSurfaceShape.kMatchOk
929 dim = attrSpec.dimensions
938 if ( (1 == len(spec))
and (dim > 0)
and ((name ==
"vtx")
or (name ==
"f")) ):
940 attrIndex = attrSpec[0]
943 numComp = self.meshGeom().faceCount
944 typeComp = om.MFn.kMeshPolygonComponent
946 numComp = len(self.meshGeom().vertices)
947 typeComp = om.MFn.kMeshVertComponent
952 if attrIndex.hasLowerBound():
953 lower = attrIndex.getLower()
954 if attrIndex.hasUpperBound():
955 upper = attrIndex.getUpper()
959 if lower > upper
or upper >= numComp:
960 result = om.MPxSurfaceShape.kMatchInvalidAttributeRange
963 path = item.getDagPath(0)
964 fnComp = om.MFnSingleIndexedComponent()
965 objComp = fnComp.create( typeComp )
967 for i
in xrange(lower, upper+1):
968 fnComp.addElement( i )
970 list.add( (path, objComp),
False )
974 result = om.MPxSurfaceShape.matchComponent(self, item, spec, list )
978 def match(self, mask, componentList):
999 if len(componentList) == 0:
1000 result = mask.intersects( om.MSelectionMask.kSelectMeshes )
1003 for comp
in componentList:
1004 if comp.apiType() == om.MFn.kMeshVertComponent
and mask.intersects(om.MSelectionMask.kSelectMeshVerts):
1012 def createFullVertexGroup(self):
1027 fnComponent = om.MFnSingleIndexedComponent()
1028 fullComponent = fnComponent.create( om.MFn.kMeshVertComponent )
1033 numVertices = len(self.meshGeom().vertices)
1034 fnComponent.setCompleteData( numVertices )
1036 return fullComponent
1038 def getShapeSelectionMask(self):
1048 selType = om.MSelectionMask.kSelectMeshes
1049 return om.MSelectionMask( selType )
1051 def getComponentSelectionMask(self):
1061 selMask = om.MSelectionMask(om.MSelectionMask.kSelectMeshVerts)
1062 selMask.addMask(om.MSelectionMask.kSelectMeshEdges)
1063 selMask.addMask(om.MSelectionMask.kSelectMeshFaces)
1066 def localShapeInAttr(self):
1079 return apiMesh.inputSurface
1081 def localShapeOutAttr(self):
1095 return apiMesh.outputSurface
1097 def worldShapeOutAttr(self):
1111 return apiMesh.outputSurface
1113 def cachedShapeAttr(self):
1125 return apiMesh.cachedSurface
1128 def geometryData(self):
1136 datablock = self.forceCache()
1137 handle = datablock.inputValue( apiMesh.inputSurface )
1138 return handle.data()
1140 def closestPoint(self, toThisPoint, theClosestPoint, tolerance):
1151 geometry = self.meshGeom()
1152 numVertices = len(geometry.vertices)
1153 for i
in xrange(numVertices):
1154 tryThisOne = geometry.vertices[i]
1158 theClosestPoint = geometry.vertices[0]
1162 def transformUsing(self, mat, componentList, cachingMode=om.MPxSurfaceShape.kNoPointCaching, pointCache=None):
1180 geometry = self.meshGeom()
1184 savePoints = (cachingMode == om.MPxSurfaceShape.kSavePoints
and pointCache
is not None)
1185 restorePoints = (cachingMode == om.MPxSurfaceShape.kRestorePoints
and pointCache
is not None)
1190 cacheLen = len(pointCache)
1195 if len(componentList) > 0:
1198 for comp
in componentList:
1199 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1200 elemCount = fnComp.elementCount
1202 for idx
in xrange(elementCount):
1203 elemIndex = fnComp.element(idx)
1204 geometry.vertices[elemIndex] = pointCache[cacheIndex]
1206 if cacheIndex >= cacheLen:
1209 if cacheIndex >= cacheLen:
1216 vertLen = len(geometry.vertices)
1217 for idx
in xrange(vertLen):
1218 geometry.vertices[idx] = pointCache[cacheIndex]
1220 if cacheIndex >= cacheLen:
1227 if len(componentList) > 0:
1230 setSizeIncrement =
True
1231 for comp
in componentList:
1232 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1233 elemCount = fnComp.elementCount
1235 if savePoints
and setSizeIncrement:
1236 pointCache.sizeIncrement = elemCount
1237 setSizeIncrement =
False
1239 for idx
in xrange(elemCount):
1240 elemIndex = fnComp.element(idx)
1242 pointCache.append(geometry.vertices[elemIndex])
1244 geometry.vertices[elemIndex] *= mat
1245 geometry.normals[idx] = geometry.normals[idx].transformAsNormal( mat )
1251 vertLen = len(geometry.vertices)
1253 pointCache.sizeIncrement = vertLen
1255 for idx
in xrange(vertLen):
1257 pointCache.append(geometry.vertices[idx])
1259 geometry.vertices[idx] *= mat
1260 geometry.normals[idx] = geometry.normals[idx].transformAsNormal( mat )
1263 self.updateCachedSurface( geometry, componentList )
1265 def tweakUsing(self, mat, componentList, cachingMode, pointCache, handle):
1286 geometry = self.meshGeom()
1290 savePoints = (cachingMode == om.MPxSurfaceShape.kSavePoints
and pointCache
is not None)
1291 updatePoints = (cachingMode == om.MPxSurfaceShape.kUpdatePoints
and pointCache
is not None)
1292 restorePoints = (cachingMode == om.MPxSurfaceShape.kRestorePoints
and pointCache
is not None)
1294 builder = handle.builder()
1299 cacheLen = len(pointCache)
1304 if len(componentList) > 0:
1307 for comp
in componentList:
1308 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1309 elemCount = fnComp.elementCount
1311 for idx
in xrange(elementCount):
1312 elemIndex = fnComp.element(idx)
1313 cachePt = pointCache[cacheIndex]
1314 elem = builder.addElement( elemIndex )
1315 elem.set3Double(cachePt.x, cachePt.y, cachePt.z)
1317 if cacheIndex >= cacheLen:
1320 if cacheIndex >= cacheLen:
1327 vertLen = len(geometry.vertices)
1328 for idx
in xrange(vertLen):
1329 cachePt = pointCache[cacheIndex]
1330 elem = builder.addElement( idx )
1331 elem.set3Double(cachePt.x, cachePt.y, cachePt.z)
1333 if cacheIndex >= cacheLen:
1341 if len(componentList) > 0:
1342 setSizeIncrement =
True
1343 for comp
in componentList:
1344 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1345 elemCount = fnComp.elementCount
1347 if savePoints
and setSizeIncrement:
1348 pointCache.sizeIncrement = elemCount
1349 setSizeIncrement =
False
1351 for idx
in xrange(elementCount):
1352 elemIndex = fnComp.element(idx)
1353 currPt = newPt = geometry.vertices[elemIndex]
1355 delta = newPt - currPt
1356 elem = builder.addElement( elemIndex )
1357 elem.set3Double(delta.x, delta.y, delta.z)
1362 pointCache.append(delta*(-1.0))
1364 elif updatePoints
and cacheIndex < cacheLen:
1365 pointCache[cacheIndex] = pointCache[cacheIndex] - delta
1372 vertLen = len(geometry.vertices)
1374 pointCache.sizeIncrement = vertLen
1376 for idx
in xrange(vertLen):
1377 currPt = newPt = geometry.vertices[idx]
1379 delta = newPt - currPt
1380 elem = builder.addElement( idx )
1381 elem.set3Double(delta.x, delta.y, delta.z)
1386 pointCache.append(delta*(-1.0))
1388 elif updatePoints
and idx < cacheLen:
1389 pointCache[cacheIndex] = pointCache[cacheIndex] - delta
1399 self.childChanged( om.MPxSurfaceShape.kBoundingBoxChanged )
1402 self.signalDirtyToViewport()
1406 def weightedTransformUsing(self, xform, space, componentList, cachingMode, pointCache, freezePlane):
1432 plg_useWeightedTransformUsingFunction = om.MPlug( self.thisMObject(), apiMesh.useWeightedTransformUsingFunction )
1433 val_useWeightedTransformUsingFunction = plg_useWeightedTransformUsingFunction.asBool()
1434 if not val_useWeightedTransformUsingFunction:
1435 om.MPxSurfaceShape.weightedTransformUsing(self, xform, space, componentList, cachingMode, pointCache, freezePlane)
1436 self.signalDirtyToViewport()
1441 savePoints = (cachingMode == om.MPxSurfaceShape.kSavePoints
and pointCache
is not None)
1442 updatePoints = (cachingMode == om.MPxSurfaceShape.kUpdatePoints
and pointCache
is not None)
1443 restorePoints = (cachingMode == om.MPxSurfaceShape.kRestorePoints
and pointCache
is not None)
1444 transformOrigPoints = (cachingMode == om.MPxSurfaceShape.kTransformOriginalPoints
and pointCache
is not None)
1447 spaceInv = om.MMatrix()
1449 spaceInv = space.inverse()
1453 geometry = self.meshGeom()
1456 setSizeIncrement =
True
1458 for comp
in componentList:
1459 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1460 elemCount = fnComp.elementCount
1461 hasWeights = fnComp.hasWeights
1462 hasSeam = (freezePlane
is not None)
1464 if savePoints
and setSizeIncrement:
1465 pointCache.sizeIncrement = elemCount
1466 setSizeIncrement =
False
1468 for idx
in xrange(elementCount):
1469 elemIndex = fnComp.element( idx )
1472 perc = fnComp.weight(idx).influence()
1475 if perc > almostZero:
1478 geometry.vertices[elemIndex] = om.MVector( pointCache[pointCacheIndex] )
1479 pointCacheIndex += 1
1484 pointCache.append( geometry.vertices[elemIndex] )
1486 elif transformOrigPoints:
1487 geometry.vertices[elemIndex] = om.MVector( pointCache[pointCacheIndex] )
1490 pointCache[pointCacheIndex] = geometry.vertices[elemIndex]
1495 mat = xform.asMatrix()
1497 mat = space * xform.asMatrix(perc) * spaceInv
1499 mat = xform.asMatrix(perc)
1502 currPt = newPt = geometry.vertices[elemIndex]
1506 if hasSeam
and fnComp.weight(idx).seam() > 0.0:
1507 newPt += freezePlane.normal() * (fnComp.weight(idx).seam() * (freezePlane.directedDistance(currPt) - freezePlane.directedDistance(newPt)))
1510 geometry.vertices[elemIndex] = newPt
1511 pointCacheIndex += 1
1514 self.updateCachedSurface( geometry, componentList )
1516 def weightedTweakUsing(self, xform, space, componentList, cachingMode, pointCache, freezePlane, handle):
1547 plg_useWeightedTweakUsingFunction = om.MPlug( self.thisMObject(), apiMesh.useWeightedTweakUsingFunction )
1548 val_useWeightedTweakUsingFunction = plg_useWeightedTweakUsingFunction.asBool()
1549 if not val_useWeightedTweakUsingFunction:
1550 om.MPxSurfaceShape.weightedTweakUsing(self, xform, space, componentList, cachingMode, pointCache, freezePlane, handle)
1553 geometry = self.meshGeom()
1557 savePoints = (cachingMode == om.MPxSurfaceShape.kSavePoints
and pointCache
is not None)
1558 updatePoints = (cachingMode == om.MPxSurfaceShape.kUpdatePoints
and pointCache
is not None)
1559 restorePoints = (cachingMode == om.MPxSurfaceShape.kRestorePoints
and pointCache
is not None)
1560 transformOrigPoints = (cachingMode == om.MPxSurfaceShape.kTransformOriginalPoints
and pointCache
is not None)
1562 builder = handle.builder()
1567 cacheLen = len(pointCache)
1574 for comp
in componentList:
1575 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1576 elemCount = fnComp.elementCount
1578 for idx
in xrange(elementCount):
1579 elemIndex = fnComp.element( idx )
1580 cachePt = pointCache[cacheIndex]
1581 elem = builder.addElement( elemIndex )
1582 elem.set3Double(cachePt.x, cachePt.y, cachePt.z)
1584 if cacheIndex >= cacheLen:
1595 setSizeIncrement =
True
1596 spaceInv = om.MMatrix()
1598 spaceInv = space.inverse()
1600 for comp
in componentList:
1601 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
1602 elemCount = fnComp.elementCount
1603 hasWeights = fnComp.hasWeights
1604 hasSeam = (freezePlane
is not None)
1606 if savePoints
and setSizeIncrement:
1607 pointCache.sizeIncrement = elemCount
1608 setSizeIncrement =
False
1610 for idx
in xrange(elementCount):
1611 elemIndex = fnComp.element( idx )
1614 perc = fnComp.weight(idx).influence()
1617 if perc > almostZero:
1623 mat = xform.asMatrix()
1625 mat = space * xform.asMatrix(perc) * spaceInv
1627 mat = xform.asMatrix(perc)
1632 if transformOrigPoints:
1633 geometry.vertices[elemIndex] = om.MVector( pointCache[cacheIndex] )
1637 currPt = newPt = geometry.vertices[elemIndex]
1642 if hasSeam
and fnComp.weight(idx).seam() > 0.0:
1643 newPt += freezePlane.normal() * (fnComp.weight(idx).seam() * (freezePlane.directedDistance(currPt) - freezePlane.directedDistance(newPt)))
1646 delta = newPt - currPt
1648 elem = builder.addElement( elemIndex )
1649 elem.set3Double(delta.x, delta.y, delta.z)
1654 pointCache.append(delta*(-1.0))
1655 elif updatePoints
and cacheIndex < cacheLen:
1656 pointCache[cacheIndex] = pointCache[cacheIndex] - delta
1666 self.childChanged( om.MPxSurfaceShape.kBoundingBoxChanged )
1670 def vertexOffsetDirection(self, component, direction, mode, normalize):
1689 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(component) )
1690 if component.apiType() != om.MFn.kMeshVertComponent:
1693 geometry = self.meshGeom()
1700 normal = geometry.normals[ idx ]
1702 if mode == om.MPxSurfaceShape.kNormal:
1705 direction.append( normal )
1714 a = math.abs(normal[0])
1716 if a < math.abs(normal[1]):
1720 if a < math.abs(normal[2]):
1726 a = math.sqrt(normal[i]*normal[i] + normal[j]*normal[j])
1727 uAxis[i] = -normal[j]/a
1728 uAxis[j] = normal[i]/a
1730 vAxis = normal^uAxis
1732 if mode == om.MPxSurfaceShape.kUTangent
or mode == om.MPxSurfaceShape.kUVNTriad:
1735 direction.append( uAxis )
1737 if mode == om.MPxSurfaceShape.kVTangent
or mode == om.MPxSurfaceShape.kUVNTriad:
1740 direction.append( vAxis )
1742 if mode == om.MPxSurfaceShape.kUVNTriad:
1745 direction.append( normal )
1751 def isBounded(self):
1760 def boundingBox(self):
1767 if self.fShapeDirty:
1771 thisNode = self.thisMObject()
1772 c1Plug = om.MPlug( thisNode, apiMesh.bboxCorner1 )
1773 c2Plug = om.MPlug( thisNode, apiMesh.bboxCorner2 )
1774 corner1Object = c1Plug.asMObject()
1775 corner2Object = c2Plug.asMObject()
1777 fnData = om.MFnNumericData()
1778 fnData.setObject( corner1Object )
1779 corner1 = fnData.getData()
1781 fnData.setObject( corner2Object )
1782 corner2 = fnData.getData()
1784 corner1Point = om.MPoint( corner1[0], corner1[1], corner1[2] )
1785 corner2Point = om.MPoint( corner2[0], corner2[1], corner2[2] )
1787 return om.MBoundingBox( corner1Point, corner2Point )
1791 def geometryIteratorSetup(self, componentList, components, forReadOnly=False):
1808 if components.isNull():
1809 vtxComponents = om.MObjectArray([self.convertToVertexComponent(c)
for c
in componentList])
1810 return apiMeshGeomIterator( self.meshGeom(), vtxComponents )
1812 return apiMeshGeomIterator( self.meshGeom(), self.convertToVertexComponent(components) )
1814 def acceptsGeometryIterator(self, arg0, arg1=None, arg2=None):
1840 def hasHistory(self):
1846 return self.fHasHistoryOnCreate
1848 def shapeDirty(self):
1855 return self.fShapeDirty
1857 def resetShapeDirty(self):
1863 self.fShapeDirty =
False
1865 def materialDirty(self):
1872 return self.fMaterialDirty
1874 def setMaterialDirty(self, dirty):
1880 self.fMaterialDirty = dirty
1882 def computeInputSurface(self, plug, datablock):
1891 if self.hasHistory():
1892 inputHandle = datablock.inputValue( apiMesh.inputSurface )
1894 surf = inputHandle.asPluginData()
1895 if not isinstance(surf, apiMeshData):
1896 raise RuntimeError(
"computeInputSurface : invalid inputSurface data found")
1900 fnDataCreator = om.MFnPluginData()
1901 fnDataCreator.create( apiMeshData.id )
1903 newCachedData = fnDataCreator.data()
1904 if not isinstance(newCachedData, apiMeshData):
1905 raise RuntimeError(
"computeInputSurface : invalid proxy cached apiMeshData object")
1907 newCachedData.fGeometry.copy(surf.fGeometry)
1909 cachedHandle = datablock.outputValue( apiMesh.cachedSurface )
1910 if not isinstance(cachedHandle, om.MDataHandle):
1911 raise RuntimeError(
"computeInputSurface : invalid cachedSurface")
1913 cachedHandle.setMPxData( newCachedData )
1915 def computeOutputSurface(self, plug, datablock):
1930 self.computeInputSurface( plug, datablock )
1934 cachedHandle = datablock.outputValue( apiMesh.cachedSurface )
1935 if not isinstance(cachedHandle, om.MDataHandle):
1936 raise RuntimeError(
"computeOutputSurface : invalid cachedSurface")
1938 cached = cachedHandle.asPluginData()
1939 if not isinstance(cached, apiMeshData):
1940 raise RuntimeError(
"computeOutputSurface : invalid cachedSurface data found")
1942 datablock.setClean( plug )
1946 if self.hasHistory():
1947 self.applyTweaks( datablock, cached.fGeometry )
1950 cpHandle = datablock.inputArrayValue( om.MPxSurfaceShape.mControlPoints )
1951 cpHandle.setAllClean()
1955 fnDataCreator = om.MFnPluginData()
1956 fnDataCreator.create( apiMeshData.id )
1958 newData = fnDataCreator.data()
1959 if not isinstance(newData, apiMeshData):
1960 raise RuntimeError(
"computeOutputSurface : invalid proxy cached apiMeshData object")
1964 newData.fGeometry.copy(cached.fGeometry)
1968 outHandle = datablock.outputValue( apiMesh.outputSurface )
1969 outHandle.setMPxData( newData )
1973 self.computeBoundingBox( datablock )
1978 def computeWorldSurface(self, plug, datablock):
1985 self.computeOutputSurface( plug, datablock )
1986 inHandle = datablock.outputValue( apiMesh.outputSurface )
1987 outSurf = inHandle.asPluginData()
1988 if not isinstance(outSurf, apiMeshData):
1989 raise RuntimeError(
"computeWorldSurface : invalid outSurf")
1993 fnDataCreator = om.MFnPluginData()
1994 fnDataCreator.create( apiMeshData.id )
1996 newData = fnDataCreator.data()
1997 if not isinstance(newData, apiMeshData):
1998 raise RuntimeError(
"computeWorldSurface : invalid proxy cached apiMeshData object")
2001 worldMat = self.getWorldMatrix(datablock, 0)
2002 newData.matrix = worldMat
2006 newData.fGeometry.copy( outSurf.fGeometry )
2010 arrayIndex = plug.logicalIndex()
2012 worldHandle = datablock.outputArrayValue( apiMesh.worldSurface )
2013 builder = worldHandle.builder()
2014 outHandle = builder.addElement( arrayIndex )
2016 outHandle.setMPxData( newData )
2021 def computeBoundingBox(self, datablock):
2031 lowerHandle = datablock.outputValue( apiMesh.bboxCorner1 )
2032 upperHandle = datablock.outputValue( apiMesh.bboxCorner2 )
2034 geometry = self.meshGeom()
2035 cnt = len(geometry.vertices)
2041 tmppnt = geometry.vertices[0]
2042 lower = [ tmppnt[0], tmppnt[1], tmppnt[2] ]
2043 upper = [ tmppnt[0], tmppnt[1], tmppnt[2] ]
2045 for i
in xrange(cnt):
2046 pnt = geometry.vertices[i]
2048 if pnt[0] < lower[0]: lower[0] = pnt[0]
2049 if pnt[1] < lower[1]: lower[1] = pnt[1]
2050 if pnt[2] < lower[2]: lower[2] = pnt[2]
2052 if pnt[0] > upper[0]: upper[0] = pnt[0]
2053 if pnt[1] > upper[1]: upper[1] = pnt[1]
2054 if pnt[2] > upper[2]: upper[2] = pnt[2]
2056 lowerHandle.set3Double(lower[0], lower[1], lower[2])
2057 upperHandle.set3Double(upper[0], upper[1], upper[2])
2059 lowerHandle.setClean()
2060 upperHandle.setClean()
2064 self.childChanged( om.MPxSurfaceShape.kBoundingBoxChanged )
2066 def convertToVertexComponent(self, components):
2068 Converts edge and face components into vertex components. This
2069 allows applying transform offsets to the vertex when edge or faces
2075 srcComponent = om.MFnSingleIndexedComponent(components)
2076 srcComponentType = srcComponent.componentType
2080 if srcComponentType != om.MFn.kMeshVertComponent:
2081 srcIndices = set(srcComponent.getElements())
2082 retVal = srcComponent.create(om.MFn.kMeshVertComponent)
2083 vtxComponent = om.MFnSingleIndexedComponent(retVal)
2085 geomPtr = self.meshGeom()
2089 for faceIdx
in xrange(0, geomPtr.faceCount):
2091 numVerts = geomPtr.face_counts[faceIdx]
2093 for v
in xrange(0, numVerts):
2094 if srcComponentType == om.MFn.kMeshEdgeComponent:
2095 if edgeId
in srcIndices:
2096 vindex1 = base + (v % numVerts)
2097 vindex2 = base + ((v+1) % numVerts)
2099 vertexId1 = geomPtr.face_connects[vindex1]
2100 vertexId2 = geomPtr.face_connects[vindex2]
2102 vtxComponent.addElement(vertexId1)
2103 vtxComponent.addElement(vertexId2)
2108 if faceIdx
in srcIndices:
2109 vindex = base + (v % numVerts)
2110 vertexId = geomPtr.face_connects[vindex]
2111 vtxComponent.addElement(vertexId)
2117 def applyTweaks(self, datablock, geometry):
2125 cpHandle = datablock.inputArrayValue( om.MPxSurfaceShape.mControlPoints )
2129 while not cpHandle.isDone():
2130 elemIndex = cpHandle.elementLogicalIndex()
2131 pntHandle = cpHandle.outputValue()
2133 offset = pntHandle.asDouble3()
2137 geometry.vertices[elemIndex] += om.MPoint(offset[0],offset[1],offset[2])
2142 def updateCachedSurface(self, geometry, componentList):
2161 datablock = self.forceCache()
2163 cachedHandle = datablock.outputValue( apiMesh.cachedSurface )
2164 cached = cachedHandle.asPluginData()
2166 dHandle = datablock.outputValue( om.MPxSurfaceShape.mControlPoints )
2171 if self.hasHistory()
and cached:
2176 self.buildControlPoints( datablock, len(geometry.vertices) )
2178 cpHandle = om.MArrayDataHandle( dHandle )
2182 for comp
in componentList:
2183 fnComp = om.MFnSingleIndexedComponent( self.convertToVertexComponent(comp) )
2184 for elemIndex
in fnComp.getElements():
2185 cpHandle.jumpToLogicalElement( elemIndex )
2186 pntHandle = cpHandle.outputValue()
2188 pnt = pntHandle.asDouble3()
2190 oldPnt = cached.fGeometry.vertices[elemIndex]
2191 newPnt = geometry.vertices[elemIndex]
2192 offset = newPnt - oldPnt
2198 pntHandle.set3Double(pnt[0], pnt[1], pnt[2])
2203 cached.fGeometry.copy(geometry)
2205 pCPs = om.MPlug( self.thisMObject(), om.MPxSurfaceShape.mControlPoints)
2206 pCPs.setMDataHandle(dHandle)
2210 self.computeBoundingBox( datablock )
2215 self.childChanged( om.MPxSurfaceShape.kBoundingBoxChanged )
2218 self.signalDirtyToViewport()
2220 def getPointValue(self, pntInd):
2227 geometry = self.cachedGeom()
2229 return geometry.vertices[ pntInd ]
2233 def getChannelValue(self, pntInd, vlInd):
2240 geometry = self.cachedGeom()
2242 return geometry.vertices[ pntInd ][ vlInd ]
2246 def setPointValue(self, pntInd, val):
2253 geometry = self.cachedGeom()
2255 geometry.vertices[ pntInd ] = om.MPoint(val)
2257 self.verticesUpdated()
2259 def setChannelValue(self, pntInd, vlInd, val):
2266 geometry = self.cachedGeom()
2268 geometry.vertices[ pntInd ][ vlInd ] = val
2270 self.verticesUpdated()
2272 def meshObject(self):
2283 datablock = self.forceCache()
2289 handle = datablock.inputValue( apiMesh.outputSurface )
2290 return handle.data()
2299 fnData = om.MFnPluginData( self.meshObject() )
2300 data = fnData.data()
2301 if not isinstance(data, apiMeshData):
2302 raise RuntimeError(
"meshGeom : failed to get apiMeshData")
2304 return data.fGeometry
2306 def cachedObject(self):
2316 datablock = self.forceCache()
2317 handle = datablock.outputValue( apiMesh.cachedSurface )
2318 return handle.data()
2320 def cachedGeom(self):
2327 fnData = om.MFnPluginData( self.cachedObject() )
2328 data = fnData.data()
2329 if not isinstance(data, apiMeshData):
2330 raise RuntimeError(
"cachedGeom : failed to get apiMeshData")
2332 return data.fGeometry
2334 def buildControlPoints(self, datablock, count):
2342 cpH = datablock.outputArrayValue( om.MPxSurfaceShape.mControlPoints )
2344 oldBuilder = cpH.builder()
2345 if count != len(oldBuilder):
2348 builder = om.MArrayDataBuilder( oldBuilder )
2350 for vtx
in xrange(count):
2351 builder.addElement( vtx )
2357 def verticesUpdated(self):
2365 self.childChanged( om.MPxSurfaceShape.kBoundingBoxChanged )
2366 self.childChanged( om.MPxSurfaceShape.kObjectChanged )
2368 def setShapeDirty(self):
2369 self.fShapeDirty =
True
2371 def notifyViewport(self):
2372 omr.MRenderer.setGeometryDrawDirty(self.thisMObject())
2374 def signalDirtyToViewport(self):
2375 self.setShapeDirty()
2376 self.notifyViewport()
2386 class apiMeshUI(omui.MPxSurfaceShapeUI):
2393 omui.MPxSurfaceShapeUI.__init__(self)
2404 def drawUV(self, view, info):
2414 meshNode = self.surfaceShape()
2415 geom = meshNode.meshGeom()
2417 if geom.uvcoords.uvcount() > 0:
2418 view.setDrawColor( om.MColor( (1.0, 0.0, 0.0) ) )
2420 if info.drawingFunction == omui.MTextureEditorDrawInfo.kDrawWireframe:
2421 self.drawUVWireframe( geom, view, info )
2423 elif info.drawingFunction == omui.MTextureEditorDrawInfo.kDrawEverything
or info.drawingFunction == omui.MTextureEditorDrawInfo.kDrawUVForSelect:
2424 self.drawUVWireframe( geom, view, info )
2425 self.drawUVMapCoordNum( geom, view, info,
True )
2428 self.drawUVWireframe( geom, view, info )
2430 def canDrawUV(self):
2436 meshNode = self.surfaceShape()
2437 geom = meshNode.meshGeom()
2438 return (geom.uvcoords.uvcount() > 0)
2442 def select(self, selectInfo, selectionList, worldSpaceSelectPts):
2456 componentSelected =
False
2459 hilited = (selectInfo.displayStatus() == omui.M3dView.kHilite)
2461 componentSelected = self.selectVertices( selectInfo, selectionList, worldSpaceSelectPts )
2462 selected = selected
or componentSelected
2465 meshNode = self.surfaceShape()
2472 priorityMask = om.MSelectionMask( om.MSelectionMask.kSelectNurbsSurfaces )
2474 item = om.MSelectionList()
2475 item.add( selectInfo.selectPath() )
2477 xformedPt = om.MPoint()
2478 if selectInfo.singleSelection():
2479 center = meshNode.boundingBox().center
2481 xformedPt *= selectInfo.selectPath().inclusiveMatrix()
2483 selectInfo.addSelection( item, xformedPt, selectionList, worldSpaceSelectPts, priorityMask,
False )
2493 def selectVertices(self, selectInfo, selectionList, worldSpaceSelectPts):
2507 view = selectInfo.view()
2508 path = selectInfo.multiPath()
2509 singleSelection = selectInfo.singleSelection()
2513 fnComponent = om.MFnSingleIndexedComponent()
2514 surfaceComponent = fnComponent.create( om.MFn.kMeshVertComponent )
2519 alignmentMatrix = om.MMatrix()
2521 alignmentMatrix = selectInfo.getAlignmentMatrix()
2523 singlePoint = om.MPoint()
2524 selectionPoint = om.MPoint()
2525 closestPointVertexIndex = -1
2530 meshNode = self.surfaceShape()
2531 geom = meshNode.meshGeom()
2536 for currentPoint
in geom.vertices:
2542 glBegin( GL_POINTS )
2543 glVertex3f( currentPoint[0], currentPoint[1], currentPoint[2] )
2546 if view.endSelect() > 0:
2550 xformedPoint = currentPoint
2551 xformedPoint.homogenize()
2552 xformedPoint *= alignmentMatrix
2554 if closestPointVertexIndex < 0
or z > previousZ:
2555 closestPointVertexIndex = vertexIndex
2556 singlePoint = currentPoint
2562 fnComponent.addElement( vertexIndex )
2566 if selected
and singleSelection:
2567 fnComponent.addElement(closestPointVertexIndex)
2571 selectionPoint = singlePoint
2572 selectionPoint *= path.inclusiveMatrix()
2577 selectionItem = om.MSelectionList()
2578 selectionItem.add( path, surfaceComponent )
2580 mask = om.MSelectionMask( om.MSelectionMask.kSelectComponentsMask )
2581 selectInfo.addSelection( selectionItem, selectionPoint, selectionList, worldSpaceSelectPts, mask,
True )
2585 def drawUVWireframe(self, geom, view, info):
2597 for i
in xrange(geom.faceCount):
2601 for v
in xrange(geom.face_counts[i]-1):
2602 uvId1 = geom.uvcoords.uvId(vid)
2603 uvId2 = geom.uvcoords.uvId(vid+1)
2605 uv1 = geom.uvcoords.getUV(uvId1)
2606 uv2 = geom.uvcoords.getUV(uvId2)
2608 glVertex3f( uv1[0], uv1[1], 0.0 )
2609 glVertex3f( uv2[0], uv2[1], 0.0 )
2612 uvId1 = geom.uvcoords.uvId(vid)
2613 uvId2 = geom.uvcoords.uvId(vid_start)
2615 uv1 = geom.uvcoords.getUV(uvId1)
2616 uv2 = geom.uvcoords.getUV(uvId2)
2618 glVertex3f( uv1[0], uv1[1], 0.0 )
2619 glVertex3f( uv2[0], uv2[1], 0.0 )
2626 def drawUVMapCoord(self, view, uvId, uv, drawNumbers):
2634 view.drawText( str(uvId), om.MPoint( uv[0], uv[1], 0 ), omui.M3dView.kCenter )
2636 glVertex3f( uv[0], uv[1], 0.0 )
2638 def drawUVMapCoordNum(self, geom, view, info, drawNumbers):
2646 ptSize = glGetFloatv( GL_POINT_SIZE )
2649 for uvId
in xrange(geom.uvcoords.uvcount()):
2650 uv = geom.uvcoords.getUV( uvId )
2651 self.drawUVMapCoord( view, uvId, uv, drawNumbers )
2653 glPointSize( ptSize )
2666 class apiMeshCreator(om.MPxNode):
2667 id = om.MTypeId(0x80089)
2677 outputSurface =
None
2681 return apiMeshCreator()
2685 typedAttr = om.MFnTypedAttribute()
2686 numericAttr = om.MFnNumericAttribute()
2687 enumAttr = om.MFnEnumAttribute()
2690 apiMeshCreator.size = numericAttr.create(
"size",
"sz", om.MFnNumericData.kDouble, 1 )
2691 numericAttr.array =
False
2692 numericAttr.usesArrayDataBuilder =
False
2693 numericAttr.hidden =
False
2694 numericAttr.keyable =
True
2695 om.MPxNode.addAttribute( apiMeshCreator.size )
2697 apiMeshCreator.shapeType = enumAttr.create(
"shapeType",
"st", 0 )
2698 enumAttr.addField(
"cube", 0 )
2699 enumAttr.addField(
"sphere", 1 )
2700 enumAttr.hidden =
False
2701 enumAttr.keyable =
True
2702 om.MPxNode.addAttribute( apiMeshCreator.shapeType )
2704 apiMeshCreator.inputMesh = typedAttr.create(
"inputMesh",
"im", om.MFnData.kMesh, om.MObject.kNullObj )
2705 typedAttr.hidden =
True
2706 om.MPxNode.addAttribute( apiMeshCreator.inputMesh )
2709 apiMeshCreator.outputSurface = typedAttr.create(
"outputSurface",
"os", apiMeshData.id, om.MObject.kNullObj )
2710 typedAttr.writable =
False
2711 om.MPxNode.addAttribute( apiMeshCreator.outputSurface )
2715 om.MPxNode.attributeAffects( apiMeshCreator.inputMesh, apiMeshCreator.outputSurface )
2716 om.MPxNode.attributeAffects( apiMeshCreator.size, apiMeshCreator.outputSurface )
2717 om.MPxNode.attributeAffects( apiMeshCreator.shapeType, apiMeshCreator.outputSurface )
2720 om.MPxNode.__init__(self)
2728 def compute(self, plug, datablock):
2736 if plug == apiMeshCreator.outputSurface:
2740 fnDataCreator = om.MFnPluginData()
2741 fnDataCreator.create( apiMeshData.id )
2743 newData = fnDataCreator.data()
2744 if not isinstance(newData, apiMeshData):
2745 raise RuntimeError(
"compute : invalid proxy cached apiMeshData object")
2747 geometry = newData.fGeometry
2752 hasHistory = self.computeInputMesh( plug, datablock, geometry )
2758 sizeHandle = datablock.inputValue( apiMeshCreator.size )
2759 shape_size = sizeHandle.asDouble()
2760 typeHandle = datablock.inputValue( apiMeshCreator.shapeType )
2761 shape_type = typeHandle.asShort()
2764 self.buildCube( shape_size, geometry )
2765 elif shape_type == 1:
2766 self.buildSphere( shape_size, 32, geometry )
2768 geometry.faceCount = len(geometry.face_counts)
2772 outHandle = datablock.outputValue( apiMeshCreator.outputSurface )
2773 outHandle.setMPxData( newData )
2774 datablock.setClean( plug )
2788 def computeInputMesh(self, plug, datablock, geometry):
2799 inputData = datablock.inputValue( apiMeshCreator.inputMesh )
2800 surf = inputData.asMesh()
2804 thisObj = self.thisMObject()
2805 surfPlug = om.MPlug( thisObj, apiMeshCreator.inputMesh )
2806 if not surfPlug.isConnected:
2807 datablock.setClean( plug )
2812 surfFn = om.MFnMesh(surf)
2813 geometry.vertices = surfFn.getPoints(om.MSpace.kObject)
2817 hasUVs = surfFn.numUVs() > 0
2818 uvs = surfFn.getUVs()
2819 geometry.uvcoords.ucoord = uvs[0]
2820 geometry.uvcoords.vcoord = uvs[1]
2822 for i
in xrange(surfFn.numPolygons()):
2823 polyVerts = surfFn.getPolygonVertices(i)
2825 pvc = len(polyVerts)
2826 geometry.face_counts.append( pvc )
2828 for v
in xrange(pvc):
2830 uvId = surfFn.getPolygonUVid(i, v)
2831 geometry.uvcoords.faceVertexIndex.append( uvId )
2832 geometry.face_connects.append( polyVerts[v] )
2834 for n
in xrange(len(geometry.vertices)):
2835 normal = surfFn.getVertexNormal(n)
2836 geometry.normals.append( normal )
2840 def buildCube(self, cube_size, geometry):
2847 geometry.vertices.clear()
2848 geometry.normals.clear()
2849 geometry.face_counts.clear()
2850 geometry.face_connects.clear()
2851 geometry.uvcoords.reset()
2853 geometry.vertices.append( om.MPoint( -cube_size, -cube_size, -cube_size ) )
2854 geometry.vertices.append( om.MPoint( cube_size, -cube_size, -cube_size ) )
2855 geometry.vertices.append( om.MPoint( cube_size, -cube_size, cube_size ) )
2856 geometry.vertices.append( om.MPoint( -cube_size, -cube_size, cube_size ) )
2857 geometry.vertices.append( om.MPoint( -cube_size, cube_size, -cube_size ) )
2858 geometry.vertices.append( om.MPoint( -cube_size, cube_size, cube_size ) )
2859 geometry.vertices.append( om.MPoint( cube_size, cube_size, cube_size ) )
2860 geometry.vertices.append( om.MPoint( cube_size, cube_size, -cube_size ) )
2862 normal_value = 0.5775
2863 geometry.normals.append( om.MVector( -normal_value, -normal_value, -normal_value ) )
2864 geometry.normals.append( om.MVector( normal_value, -normal_value, -normal_value ) )
2865 geometry.normals.append( om.MVector( normal_value, -normal_value, normal_value ) )
2866 geometry.normals.append( om.MVector( -normal_value, -normal_value, normal_value ) )
2867 geometry.normals.append( om.MVector( -normal_value, normal_value, -normal_value ) )
2868 geometry.normals.append( om.MVector( -normal_value, normal_value, normal_value ) )
2869 geometry.normals.append( om.MVector( normal_value, normal_value, normal_value ) )
2870 geometry.normals.append( om.MVector( normal_value, normal_value, -normal_value ) )
2875 uv_pts = [ [ 0.375, 0.0 ],
2892 num_face_connects = 24
2893 uv_fvid = [ 0, 1, 2, 3,
2900 for i
in xrange(uv_count):
2901 geometry.uvcoords.append_uv( uv_pts[i][0], uv_pts[i][1] )
2903 for i
in xrange(num_face_connects):
2904 geometry.uvcoords.faceVertexIndex.append( uv_fvid[i] )
2910 face_counts = [ 4, 4, 4, 4, 4, 4 ]
2912 for i
in xrange(num_faces):
2913 geometry.face_counts.append( face_counts[i] )
2917 face_connects = [ 0, 1, 2, 3,
2924 for i
in xrange(num_face_connects):
2925 geometry.face_connects.append( face_connects[i] )
2927 def buildSphere(self, radius, divisions, geometry):
2935 geometry.vertices.clear()
2936 geometry.normals.clear()
2937 geometry.face_counts.clear()
2938 geometry.face_connects.clear()
2939 geometry.uvcoords.reset()
2943 u_delta = math.pi / divisions
2944 v_delta = 2 * math.pi / divisions
2946 topPole = om.MPoint( 0.0, radius, 0.0 )
2947 botPole = om.MPoint( 0.0, -radius, 0.0 )
2951 geometry.vertices.append( botPole )
2952 geometry.normals.append( botPole - om.MPoint.kOrigin )
2954 for i
in xrange(divisions-1):
2958 for j
in xrange(divisions):
2959 x = radius * math.cos(u) * math.cos(v)
2960 y = radius * math.sin(u)
2961 z = radius * math.cos(u) * math.sin(v)
2963 pnt = om.MPoint( x, y, z )
2964 geometry.vertices.append( pnt )
2965 geometry.normals.append( pnt - om.MPoint.kOrigin )
2968 geometry.vertices.append( topPole )
2969 geometry.normals.append( topPole - om.MPoint.kOrigin )
2975 for i
in xrange(divisions):
2976 for j
in xrange(divisions):
2978 geometry.face_counts.append( 3 )
2980 geometry.face_connects.append( 0 )
2981 geometry.face_connects.append( j + vid )
2982 if j == divisions-1:
2983 geometry.face_connects.append( vid )
2985 geometry.face_connects.append( j + vid + 1 )
2987 elif i == divisions-1:
2988 geometry.face_counts.append( 3 )
2990 geometry.face_connects.append( j + vid + 1 - divisions )
2991 geometry.face_connects.append( vid + 1 )
2992 if j == divisions-1:
2993 geometry.face_connects.append( vid + 1 - divisions )
2995 geometry.face_connects.append( j + vid + 2 - divisions )
2998 geometry.face_counts.append( 4 )
3000 geometry.face_connects.append( j + vid + 1 - divisions )
3001 geometry.face_connects.append( j + vid + 1 )
3002 if j == divisions-1:
3003 geometry.face_connects.append( vid + 1 )
3004 geometry.face_connects.append( vid + 1 - divisions )
3006 geometry.face_connects.append( j + vid + 2 )
3007 geometry.face_connects.append( j + vid + 2 - divisions )
3014 class ShadedItemUserData(om.MUserData):
3015 def __init__(self, override):
3016 om.MUserData.__init__(self,
False)
3017 self.fOverride = override
3021 class apiMeshHWSelectionUserData(om.MUserData):
3023 om.MUserData.__init__(self,
True)
3024 self.fMeshGeom =
None
3025 self.fInstanceIndex = 0
3026 self.fFaceViewSelectedStates =
None
3029 sViewSelectedInstanceMark = -1
3030 sViewSelectedFaceSelectionNames = set()
3035 def gatherViewSelectedFaceInfo(frameContext, instances, meshGeom):
3036 viewSelectedFaceInfo = collections.defaultdict(list)
3038 if (
not meshGeom
or meshGeom.faceCount <= 0):
3039 return False, viewSelectedFaceInfo
3041 renderingDestinationResult = frameContext.renderingDestination()
3043 if (renderingDestinationResult[0] != omr.MFrameContext.k3dViewport):
3044 return False, viewSelectedFaceInfo
3046 view = omui.M3dView.getM3dViewFromModelPanel(renderingDestinationResult[1])
3048 if(
not view
or not view.viewIsFiltered()):
3049 return False, viewSelectedFaceInfo
3052 viewSelectedList = view.filteredObjectList()
3053 if(viewSelectedList):
3055 for instIdx
in xrange(len(instances)):
3056 intersectionList = om.MSelectionList()
3058 intersectionList.add(instances[instIdx])
3059 intersectionList.intersect(viewSelectedList,
True)
3061 selectionIt = om.MItSelectionList(intersectionList)
3062 while not selectionIt.isDone():
3063 comp = selectionIt.getComponent()[1]
3066 viewSelectedFaceInfo[instIdx].append(sViewSelectedInstanceMark)
3069 fnComp = om.MFnSingleIndexedComponent(comp)
3071 if (fnComp.componentType == om.MFn.kMeshPolygonComponent):
3072 faceIds = fnComp.getElements()
3074 for i
in xrange(len(faceIds)):
3076 if (faceId >= 0
and faceId < meshGeom.faceCount):
3077 viewSelectedFaceInfo[instIdx].append(faceId)
3081 return True, viewSelectedFaceInfo
3085 def shouldDrawInstance(viewSelectedFaceInfo, instIdx):
3088 if instIdx
in viewSelectedFaceInfo:
3089 faceIds = viewSelectedFaceInfo[instIdx]
3092 if id != sViewSelectedInstanceMark:
3110 class simpleComponentConverter_subsceneOverride(omr.MPxComponentConverter):
3111 def __init__(self, componentType, selectionType):
3112 omr.MPxComponentConverter.__init__(self)
3114 self.fComponentType = componentType
3115 self.fSelectionType = selectionType
3117 self.fComponent = om.MFnSingleIndexedComponent()
3118 self.fComponentObject = om.MObject.kNullObj
3119 self.fLookupTable = []
3121 def initialize(self, renderItem):
3123 self.fComponentObject = self.fComponent.create( self.fComponentType )
3128 if self.fComponentType == om.MFn.kMeshPolygonComponent:
3129 selectionData = renderItem.customData()
3130 if isinstance(selectionData, apiMeshHWSelectionUserData):
3131 meshGeom = selectionData.fMeshGeom
3132 faceStates = selectionData.fFaceViewSelectedStates
3136 for i
in xrange(meshGeom.faceCount):
3137 numVerts = meshGeom.face_counts[i]
3139 if(
not faceStates
or faceStates[i]):
3140 numTriangles += numVerts - 2
3142 self.fLookupTable = [0]*numTriangles
3146 for faceId
in xrange(meshGeom.faceCount):
3148 numVerts = meshGeom.face_counts[faceId]
3150 if(
not faceStates
or faceStates[faceId]):
3151 for v
in xrange(1, numVerts-1):
3152 self.fLookupTable[triId] = faceId
3155 def addIntersection(self, intersection):
3162 if self.fComponentType == om.MFn.kMeshEdgeComponent:
3165 if intersection.instanceID == 1
or intersection.instanceID == 3:
3168 idx = intersection.index
3170 if self.fComponentType == om.MFn.kMeshPolygonComponent:
3171 if idx >= 0
and idx < len(self.fLookupTable):
3172 idx = self.fLookupTable[idx]
3174 self.fComponent.addElement(idx)
3176 def component(self):
3178 return self.fComponentObject
3180 def selectionMask(self):
3182 return self.fSelectionType
3186 def creatorVertexSelection():
3187 mask = om.MSelectionMask(om.MSelectionMask.kSelectMeshVerts)
3188 mask.addMask(om.MSelectionMask.kSelectPointsForGravity)
3189 return simpleComponentConverter_subsceneOverride(om.MFn.kMeshVertComponent, mask)
3193 def creatorEdgeSelection():
3194 return simpleComponentConverter_subsceneOverride(om.MFn.kMeshEdgeComponent, om.MSelectionMask.kSelectMeshEdges)
3198 def creatorFaceSelection():
3199 return simpleComponentConverter_subsceneOverride(om.MFn.kMeshPolygonComponent, om.MSelectionMask.kSelectMeshFaces)
3201 class apiMeshSubSceneOverride(omr.MPxSubSceneOverride):
3202 sWireName =
"apiMeshWire"
3203 sSelectName =
"apiMeshSelection"
3204 sBoxName =
"apiMeshBox"
3205 sSelectedBoxName =
"apiMeshBoxSelection"
3206 sShadedName =
"apiMeshShaded"
3207 sTexturedName =
"apiMeshTextured"
3209 sVertexSelectionName =
"apiMeshVertexSelection"
3210 sEdgeSelectionName =
"apiMeshEdgeSelection"
3211 sFaceSelectionName =
"apiMeshFaceSelection"
3213 sActiveVertexName =
"apiMeshActiveVertex"
3214 sActiveEdgeName =
"apiMeshActiveEdge"
3215 sActiveFaceName =
"apiMeshActiveFace"
3217 sNameSeparator =
"_"
3220 def __init__(self, transform, isSelected):
3221 self.fTransform = transform
3222 self.fIsSelected = isSelected
3226 return apiMeshSubSceneOverride(obj)
3229 def shadedItemLinkLost(userData):
3230 if not userData
is None and not userData.fOverride
is None:
3231 if not userData.fOverride.fMesh
is None:
3232 userData.fOverride.fMesh.setMaterialDirty(
True)
3233 userData.fOverride =
None
3236 def __init__(self, obj):
3237 omr.MPxSubSceneOverride.__init__(self, obj)
3239 node = om.MFnDependencyNode(obj)
3240 self.fMesh = node.userNode()
3241 self.fObject = om.MObject(obj)
3242 self.fWireShader =
None
3243 self.fThickWireShader =
None
3244 self.fSelectShader =
None
3245 self.fThickSelectShader =
None
3246 self.fShadedShader =
None
3247 self.fVertexComponentShader =
None
3248 self.fEdgeComponentShader =
None
3249 self.fFaceComponentShader =
None
3250 self.fPositionBuffer =
None
3251 self.fNormalBuffer =
None
3252 self.fBoxPositionBuffer =
None
3253 self.fWireIndexBuffer =
None
3254 self.fBoxIndexBuffer =
None
3255 self.fShadedIndexBuffer =
None
3256 self.fActiveVerticesIndexBuffer =
None
3257 self.fActiveEdgesIndexBuffer =
None
3258 self.fActiveFacesIndexBuffer =
None
3259 self.fThickLineWidth = -1.0
3260 self.fQueuedLineWidth = -1.0
3261 self.fNumInstances = 0
3262 self.fIsInstanceMode =
False
3263 self.fQueueUpdate =
False
3264 self.fUseQueuedLineUpdate =
False
3266 self.fInstanceInfoCache = collections.defaultdict(set)
3268 self.fActiveVerticesSet = set()
3269 self.fActiveEdgesSet = set()
3270 self.fActiveFacesSet = set()
3272 self.fViewSelectedFaceInfoCache = collections.defaultdict(list)
3273 self.fLinkLostCallbackData = []
3278 shaderMgr = omr.MRenderer.getShaderManager()
3280 if self.fWireShader:
3281 shaderMgr.releaseShader(self.fWireShader)
3282 self.fWireShader =
None
3284 if self.fThickWireShader:
3285 shaderMgr.releaseShader(self.fThickWireShader)
3286 self.fThickWireShader =
None
3288 if self.fSelectShader:
3289 shaderMgr.releaseShader(self.fSelectShader)
3290 self.fSelectShader =
None
3292 if self.fThickSelectShader:
3293 shaderMgr.releaseShader(self.fThickSelectShader)
3294 self.fThickSelectShader =
None
3296 if self.fShadedShader:
3297 shaderMgr.releaseShader(self.fShadedShader)
3298 self.fShadedShader =
None
3300 if self.fVertexComponentShader:
3301 shaderMgr.releaseShader(self.fVertexComponentShader)
3302 self.fVertexComponentShader =
None
3304 if self.fEdgeComponentShader:
3305 shaderMgr.releaseShader(self.fEdgeComponentShader)
3306 self.fEdgeComponentShader =
None
3308 if self.fFaceComponentShader:
3309 shaderMgr.releaseShader(self.fFaceComponentShader)
3310 self.fFaceComponentShader =
None
3314 def supportedDrawAPIs(self):
3316 return omr.MRenderer.kOpenGL | omr.MRenderer.kDirectX11 | omr.MRenderer.kOpenGLCoreProfile
3318 def requiresUpdate(self, container, frameContext):
3320 if len(container) == 0:
3327 def update(self, container, frameContext):
3329 self.manageRenderItems(container, frameContext, self.fMesh.shapeDirty()
or len(container) == 0)
3332 self.fMesh.resetShapeDirty()
3334 def furtherUpdateRequired(self, frameContext):
3335 if self.fUseQueuedLineUpdate:
3336 if not frameContext.inUserInteraction()
and not frameContext.userChangingViewContext():
3337 return self.fQueueUpdate
3341 def manageRenderItems(self, container, frameContext, updateGeometry):
3343 if not self.fMesh
or self.fObject.isNull():
3346 shaderMgr = omr.MRenderer.getShaderManager()
3350 node = om.MFnDagNode(self.fObject)
3351 instances = node.getAllPaths()
3352 if len(instances) == 0:
3356 sRed = [1.0, 0.0, 0.0, 1.0]
3357 sGreen = [0.0, 1.0, 0.0, 1.0]
3358 sWhite = [1.0, 1.0, 1.0, 1.0]
3361 if not self.fWireShader:
3362 self.fWireShader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader)
3363 self.fWireShader.setParameter(
"solidColor", sRed)
3365 if not self.fThickWireShader:
3366 self.fThickWireShader = shaderMgr.getStockShader(omr.MShaderManager.k3dThickLineShader)
3367 self.fThickWireShader.setParameter(
"solidColor", sRed)
3369 if not self.fSelectShader:
3370 self.fSelectShader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader)
3371 self.fSelectShader.setParameter(
"solidColor", sGreen)
3373 if not self.fThickSelectShader:
3374 self.fThickSelectShader = shaderMgr.getStockShader(omr.MShaderManager.k3dThickLineShader)
3375 self.fThickSelectShader.setParameter(
"solidColor", sGreen)
3377 if not self.fVertexComponentShader:
3378 self.fVertexComponentShader = shaderMgr.getStockShader(omr.MShaderManager.k3dFatPointShader)
3379 self.fVertexComponentShader.setParameter(
"solidColor", sWhite)
3380 self.fVertexComponentShader.setParameter(
"pointSize", [5.0, 5.0])
3382 if not self.fEdgeComponentShader:
3383 self.fEdgeComponentShader = shaderMgr.getStockShader(omr.MShaderManager.k3dThickLineShader)
3384 self.fEdgeComponentShader.setParameter(
"solidColor", sWhite)
3385 self.fEdgeComponentShader.setParameter(
"lineWidth", [2.0, 2.0])
3387 if not self.fFaceComponentShader:
3388 self.fFaceComponentShader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader)
3389 self.fFaceComponentShader.setParameter(
"solidColor", sWhite)
3391 if not self.fShadedShader:
3392 self.fShadedShader = shaderMgr.getStockShader(omr.MShaderManager.k3dBlinnShader)
3396 self.rebuildGeometryBuffers()
3398 if not all((self.fPositionBuffer, self.fNormalBuffer, self.fBoxPositionBuffer, self.fWireIndexBuffer, self.fBoxIndexBuffer, self.fShadedIndexBuffer)):
3401 isActiveViewFiltered, viewSelectedFaceInfo = gatherViewSelectedFaceInfo(frameContext, instances, self.fMesh.meshGeom())
3403 selectedList = om.MGlobal.getActiveSelectionList()
3405 anyMatrixChanged =
False
3406 itemsChanged =
False
3407 instanceArrayLength = len(instances)
3408 numInstanceSelected = 0
3409 numInstanceUnselected = 0
3412 instanceMatrixArray = om.MMatrixArray(instanceArrayLength)
3413 selectedInstanceMatrixArray = om.MMatrixArray(instanceArrayLength)
3414 unselectedInstanceMatrixArray = om.MMatrixArray(instanceArrayLength)
3416 for instIdx
in xrange(instanceArrayLength):
3422 instance = instances[instIdx]
3423 instanceNum = instance.instanceNumber()
3425 if (instance.isValid
and instance.isVisible
and (
not isActiveViewFiltered
or shouldDrawInstance(viewSelectedFaceInfo, instIdx))):
3426 instanceInfo = apiMeshSubSceneOverride.InstanceInfo(instance.inclusiveMatrix(), useSelectHighlight(selectedList, instance))
3428 if( instanceNum
not in self.fInstanceInfoCache
or
3429 self.fInstanceInfoCache[instanceNum].fIsSelected != instanceInfo.fIsSelected
or
3430 not self.fInstanceInfoCache[instanceNum].fTransform.isEquivalent(instanceInfo.fTransform)):
3432 self.fInstanceInfoCache[instanceNum] = instanceInfo
3433 anyMatrixChanged =
True
3435 instanceMatrixArray[numInstances] = instanceInfo.fTransform
3438 if instanceInfo.fIsSelected:
3439 selectedInstanceMatrixArray[numInstanceSelected] = instanceInfo.fTransform
3440 numInstanceSelected += 1
3442 unselectedInstanceMatrixArray[numInstanceUnselected] = instanceInfo.fTransform
3443 numInstanceUnselected += 1
3445 if (instanceNum
in self.fInstanceInfoCache):
3447 del self.fInstanceInfoCache[instanceNum]
3449 anyMatrixChanged =
True
3451 instanceMatrixArray.setLength(numInstances)
3452 selectedInstanceMatrixArray.setLength(numInstanceSelected)
3453 unselectedInstanceMatrixArray.setLength(numInstanceUnselected)
3454 if self.fNumInstances != numInstances:
3455 anyMatrixChanged =
True
3456 self.fNumInstances = numInstances
3458 anyInstanceSelected = numInstanceSelected > 0
3459 anyInstanceUnselected = numInstanceUnselected > 0
3461 activeVerticesSet = set()
3462 activeEdgesSet = set()
3463 activeFacesSet = set()
3465 meshGeom = self.fMesh.meshGeom()
3466 if meshGeom
and self.fMesh.hasActiveComponents():
3467 activeComponents = self.fMesh.activeComponents()
3468 if len(activeComponents) > 0:
3469 fnComponent = om.MFnSingleIndexedComponent( activeComponents[0] )
3470 if fnComponent.elementCount > 0:
3471 activeIds = fnComponent.getElements()
3473 if fnComponent.componentType == om.MFn.kMeshVertComponent:
3474 activeVerticesSet = set(activeIds)
3476 elif fnComponent.componentType == om.MFn.kMeshEdgeComponent:
3477 activeEdgesSet = set(activeIds)
3479 elif fnComponent.componentType == om.MFn.kMeshPolygonComponent:
3480 activeFacesSet = set(activeIds)
3483 updateActiveItems = updateGeometry
or self.fActiveVerticesSet != activeVerticesSet
or self.fActiveEdgesSet != activeEdgesSet
or self.fActiveFacesSet != activeFacesSet
3484 self.fActiveVerticesSet = activeVerticesSet
3485 self.fActiveEdgesSet = activeEdgesSet
3486 self.fActiveFacesSet = activeFacesSet
3488 if updateActiveItems:
3489 self.rebuildActiveComponentIndexBuffers()
3491 anyVertexSelected = bool(self.fActiveVerticesSet)
3492 anyEdgeSelected = bool(self.fActiveEdgesSet)
3493 anyFaceSelected = bool(self.fActiveFacesSet)
3495 if (anyVertexSelected
and not self.fActiveVerticesIndexBuffer)
or (anyEdgeSelected
and not self.fActiveEdgesIndexBuffer)
or (anyFaceSelected
and not self.fActiveFacesIndexBuffer):
3500 wireItem = container.find(self.sWireName)
3501 if not wireItem
and anyInstanceUnselected:
3502 wireItem = omr.MRenderItem.create( self.sWireName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
3503 wireItem.setDrawMode(omr.MGeometry.kWireframe)
3504 wireItem.setDepthPriority(omr.MRenderItem.sActiveWireDepthPriority)
3505 wireItem.setShader(self.fWireShader)
3506 container.add(wireItem)
3509 elif wireItem
and not anyInstanceUnselected:
3510 container.remove(self.sWireName)
3514 selectItem = container.find(self.sSelectName)
3515 if not selectItem
and anyInstanceSelected:
3516 selectItem = omr.MRenderItem.create( self.sSelectName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
3517 selectItem.setDrawMode(omr.MGeometry.kWireframe | omr.MGeometry.kShaded | omr.MGeometry.kTextured)
3518 selectItem.setDepthPriority(omr.MRenderItem.sActiveWireDepthPriority)
3519 selectItem.setShader(self.fSelectShader)
3520 container.add(selectItem)
3523 elif selectItem
and not anyInstanceSelected:
3524 container.remove(self.sSelectName)
3528 boxItem = container.find(self.sBoxName)
3529 if not boxItem
and anyInstanceUnselected:
3530 boxItem = omr.MRenderItem.create( self.sBoxName, omr.MRenderItem.NonMaterialSceneItem, omr.MGeometry.kLines)
3531 boxItem.setDrawMode(omr.MGeometry.kBoundingBox)
3532 boxItem.setShader(self.fWireShader)
3533 container.add(boxItem)
3536 elif boxItem
and not anyInstanceUnselected:
3537 container.remove(self.sBoxName)
3541 selectedBoxItem = container.find(self.sSelectedBoxName)
3542 if not selectedBoxItem
and anyInstanceSelected:
3543 selectedBoxItem = omr.MRenderItem.create( self.sSelectedBoxName, omr.MRenderItem.NonMaterialSceneItem, omr.MGeometry.kLines)
3544 selectedBoxItem.setDrawMode(omr.MGeometry.kBoundingBox)
3545 selectedBoxItem.setShader(self.fSelectShader)
3546 container.add(selectedBoxItem)
3549 elif selectedBoxItem
and not anyInstanceSelected:
3550 container.remove(self.sSelectedBoxName)
3551 selectedBoxItem =
None
3554 shadedItem = container.find(self.sShadedName)
3557 shadedItem = omr.MRenderItem.create( self.sShadedName, omr.MRenderItem.MaterialSceneItem, omr.MGeometry.kTriangles)
3558 shadedItem.setDrawMode(omr.MGeometry.kShaded)
3559 shadedItem.setExcludedFromPostEffects(
False)
3560 shadedItem.setCastsShadows(
True)
3561 shadedItem.setReceivesShadows(
True)
3562 container.add(shadedItem)
3565 texturedItem = container.find(self.sTexturedName)
3566 if not texturedItem:
3568 texturedItem = omr.MRenderItem.create( self.sTexturedName, omr.MRenderItem.MaterialSceneItem, omr.MGeometry.kTriangles)
3569 texturedItem.setDrawMode(omr.MGeometry.kTextured)
3570 texturedItem.setExcludedFromPostEffects(
False)
3571 texturedItem.setCastsShadows(
True)
3572 texturedItem.setReceivesShadows(
True)
3573 container.add(texturedItem)
3582 connectedPlugs = om.MPlugArray()
3583 (sets, comps) = node.getConnectedSetsAndMembers(0,
True)
3585 dn = om.MFnDependencyNode(obj)
3586 shaderPlug = dn.findPlug(
"surfaceShader",
True)
3587 connectedPlugs = shaderPlug.connectedTo(
True,
False)
3588 if len(connectedPlugs) > 0:
3589 shader = connectedPlugs[0].node()
3594 updateMaterial = self.fMesh.materialDirty()
3595 self.fMesh.setMaterialDirty(
False);
3598 if updateMaterial
or not shadedItem.isShaderFromNode():
3600 not shadedItem.setShaderFromNode(shader,
3602 apiMeshSubSceneOverride.shadedItemLinkLost,
3603 ShadedItemUserData(self),
3605 shadedItem.setShader(self.fShadedShader)
3608 if updateMaterial
or not texturedItem.isShaderFromNode():
3610 not texturedItem.setShaderFromNode(shader,
3612 apiMeshSubSceneOverride.shadedItemLinkLost,
3613 ShadedItemUserData(self),
3615 texturedItem.setShader(self.fShadedShader)
3617 print "Unexpected error:", sys.exc_info()[0]
3621 vertexSelectionItem = container.find(self.sVertexSelectionName)
3622 if not vertexSelectionItem:
3623 vertexSelectionItem = omr.MRenderItem.create( self.sVertexSelectionName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
3625 vertexSelectionItem.setDrawMode(omr.MGeometry.kSelectionOnly)
3627 mask = om.MSelectionMask(om.MSelectionMask.kSelectMeshVerts)
3628 mask.addMask(om.MSelectionMask.kSelectPointsForGravity)
3629 vertexSelectionItem.setSelectionMask( mask )
3631 vertexSelectionItem.setDepthPriority(omr.MRenderItem.sSelectionDepthPriority)
3632 vertexSelectionItem.setShader(self.fVertexComponentShader)
3633 container.add(vertexSelectionItem)
3639 useDrawInstancingOnEdgeSelectionItem =
False
3642 edgeSelectionItem = container.find(self.sEdgeSelectionName)
3643 if not edgeSelectionItem:
3645 drawMode = omr.MGeometry.kSelectionOnly
3646 depthPriority = omr.MRenderItem.sSelectionDepthPriority
3647 if useDrawInstancingOnEdgeSelectionItem:
3649 drawMode = omr.MGeometry.kAll
3651 depthPriority = omr.MRenderItem.sActiveWireDepthPriority-1
3653 edgeSelectionItem = omr.MRenderItem.create( self.sEdgeSelectionName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
3654 edgeSelectionItem.setDrawMode(drawMode)
3656 edgeSelectionItem.setDepthPriority(depthPriority)
3658 edgeSelectionItem.setSelectionMask( om.MSelectionMask.kSelectMeshEdges )
3659 edgeSelectionItem.setShader(self.fWireShader)
3660 container.add(edgeSelectionItem)
3664 faceSelectionItem = container.find(self.sFaceSelectionName)
3665 if not faceSelectionItem:
3666 faceSelectionItem = omr.MRenderItem.create( self.sFaceSelectionName, omr.MRenderItem.DecorationItem, omr.MGeometry.kTriangles)
3668 faceSelectionItem.setDrawMode(omr.MGeometry.kSelectionOnly)
3670 faceSelectionItem.setSelectionMask( om.MSelectionMask.kSelectMeshFaces )
3672 faceSelectionItem.setDepthPriority(omr.MRenderItem.sSelectionDepthPriority)
3673 faceSelectionItem.setShader(self.fFaceComponentShader)
3674 container.add(faceSelectionItem)
3679 mySelectionData = apiMeshHWSelectionUserData()
3680 mySelectionData.fMeshGeom = self.fMesh.meshGeom()
3681 faceSelectionItem.setCustomData(mySelectionData)
3684 activeVertexItem = container.find(self.sActiveVertexName)
3685 if not activeVertexItem
and anyVertexSelected:
3686 activeVertexItem = omr.MRenderItem.create( self.sActiveVertexName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
3687 activeVertexItem.setDrawMode(omr.MGeometry.kAll)
3688 activeVertexItem.setDepthPriority(omr.MRenderItem.sActivePointDepthPriority)
3689 activeVertexItem.setShader(self.fVertexComponentShader)
3690 container.add(activeVertexItem)
3693 elif activeVertexItem
and not anyVertexSelected:
3694 container.remove(self.sActiveVertexName)
3695 activeVertexItem =
None
3699 activeEdgeItem = container.find(self.sActiveEdgeName)
3700 if not activeEdgeItem
and anyEdgeSelected:
3701 activeEdgeItem = omr.MRenderItem.create( self.sActiveEdgeName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
3702 activeEdgeItem.setDrawMode(omr.MGeometry.kAll)
3703 activeEdgeItem.setDepthPriority(omr.MRenderItem.sActiveLineDepthPriority)
3704 activeEdgeItem.setShader(self.fEdgeComponentShader)
3705 container.add(activeEdgeItem)
3708 elif activeEdgeItem
and not anyEdgeSelected:
3709 container.remove(self.sActiveEdgeName)
3710 activeEdgeItem =
None
3714 activeFaceItem = container.find(self.sActiveFaceName)
3715 if not activeFaceItem
and anyFaceSelected:
3716 activeFaceItem = omr.MRenderItem.create( self.sActiveFaceName, omr.MRenderItem.DecorationItem, omr.MGeometry.kTriangles)
3717 activeFaceItem.setDrawMode(omr.MGeometry.kAll)
3718 activeFaceItem.setDepthPriority(omr.MRenderItem.sActiveLineDepthPriority)
3719 activeFaceItem.setShader(self.fFaceComponentShader)
3720 container.add(activeFaceItem)
3723 elif activeFaceItem
and not anyFaceSelected:
3724 container.remove(self.sActiveFaceName)
3725 activeFaceItem =
None
3729 lineWidth = frameContext.getGlobalLineWidth()
3730 userWidthChange =
not floatApproxEqual(lineWidth, self.fThickLineWidth)
3733 targetRefinedLineWidth = 50.0
3735 self.fThickLineWidth = lineWidth
3739 if self.fUseQueuedLineUpdate:
3740 self.fQueuedLineWidth = lineWidth
3741 if self.fQueuedLineWidth < targetRefinedLineWidth:
3742 self.fQueueUpdate =
True
3748 if self.fUseQueuedLineUpdate
and self.fQueueUpdate:
3749 if self.fQueuedLineWidth < targetRefinedLineWidth:
3750 lineWidth = self.fQueuedLineWidth
3751 self.fQueuedLineWidth += 1
3752 self.fQueueUpdate =
True
3757 self.fQueueUpdate =
False
3760 if not floatApproxEqual(lineWidth, 1.0):
3762 lineWidthArray = [ lineWidth, lineWidth ]
3763 self.fThickWireShader.setParameter(
"lineWidth", lineWidthArray)
3764 self.fThickSelectShader.setParameter(
"lineWidth", lineWidthArray)
3766 wireItem.setShader(self.fThickWireShader)
3768 selectItem.setShader(self.fThickSelectShader)
3772 wireItem.setShader(self.fWireShader)
3774 selectItem.setShader(self.fSelectShader)
3777 if itemsChanged
or updateGeometry:
3778 bounds = self.fMesh.boundingBox()
3780 wireBuffers = omr.MVertexBufferArray()
3781 wireBuffers.append(self.fPositionBuffer,
"positions")
3783 self.setGeometryForRenderItem(wireItem, wireBuffers, self.fWireIndexBuffer, bounds)
3785 self.setGeometryForRenderItem(selectItem, wireBuffers, self.fWireIndexBuffer, bounds)
3787 boxBuffers = omr.MVertexBufferArray()
3788 boxBuffers.append(self.fBoxPositionBuffer,
"positions")
3790 self.setGeometryForRenderItem(boxItem, boxBuffers, self.fBoxIndexBuffer, bounds)
3792 self.setGeometryForRenderItem(selectedBoxItem, boxBuffers, self.fBoxIndexBuffer, bounds)
3794 shadedBuffers = omr.MVertexBufferArray()
3795 shadedBuffers.append(self.fPositionBuffer,
"positions")
3796 shadedBuffers.append(self.fNormalBuffer,
"normals")
3797 self.setGeometryForRenderItem(shadedItem, shadedBuffers, self.fShadedIndexBuffer, bounds)
3798 self.setGeometryForRenderItem(texturedItem, shadedBuffers, self.fShadedIndexBuffer, bounds)
3801 self.setGeometryForRenderItem(vertexSelectionItem, wireBuffers, objectBox = bounds)
3802 self.setGeometryForRenderItem(edgeSelectionItem, wireBuffers, self.fWireIndexBuffer, bounds)
3803 self.setGeometryForRenderItem(faceSelectionItem, wireBuffers, self.fShadedIndexBuffer, bounds)
3806 if itemsChanged
or updateActiveItems:
3807 bounds = self.fMesh.boundingBox()
3809 vertexBuffer = omr.MVertexBufferArray()
3810 vertexBuffer.append(self.fPositionBuffer,
"positions")
3812 if activeVertexItem:
3813 self.setGeometryForRenderItem(activeVertexItem, vertexBuffer, self.fActiveVerticesIndexBuffer, bounds)
3815 self.setGeometryForRenderItem(activeEdgeItem, vertexBuffer, self.fActiveEdgesIndexBuffer, bounds)
3817 self.setGeometryForRenderItem(activeFaceItem, vertexBuffer, self.fActiveFacesIndexBuffer, bounds)
3820 if itemsChanged
or anyMatrixChanged:
3821 if not self.fIsInstanceMode
and numInstances == 1:
3824 objToWorld = instanceMatrixArray[0]
3827 wireItem.setMatrix(objToWorld)
3829 selectItem.setMatrix(objToWorld)
3831 boxItem.setMatrix(objToWorld)
3833 selectedBoxItem.setMatrix(objToWorld)
3834 shadedItem.setMatrix(objToWorld)
3835 texturedItem.setMatrix(objToWorld)
3837 vertexSelectionItem.setMatrix(objToWorld)
3838 edgeSelectionItem.setMatrix(objToWorld)
3839 faceSelectionItem.setMatrix(objToWorld)
3841 if useDrawInstancingOnEdgeSelectionItem:
3844 transform1 = objToWorld
3847 transform2 = objToWorld * 2
3850 transform3 = objToWorld * 3
3854 transforms = om.MMatrixArray((transform1, transform2, transform3))
3855 self.setInstanceTransformArray(edgeSelectionItem, transforms)
3860 self.removeAllInstances(edgeSelectionItem)
3864 newInstanceId = self.addInstanceTransform(edgeSelectionItem, transform1)
3865 print "newInstanceId " + str(newInstanceId)
3866 newInstanceId = self.addInstanceTransform(edgeSelectionItem, transform2)
3867 print "newInstanceId " + str(newInstanceId)
3868 newInstanceId = self.addInstanceTransform(edgeSelectionItem, transform3)
3869 print "newInstanceId " + str(newInstanceId)
3871 if activeVertexItem:
3872 activeVertexItem.setMatrix(objToWorld)
3874 activeEdgeItem.setMatrix(objToWorld)
3876 activeFaceItem.setMatrix(objToWorld)
3891 self.setInstanceTransformArray(wireItem, unselectedInstanceMatrixArray)
3893 self.setInstanceTransformArray(selectItem, selectedInstanceMatrixArray)
3895 self.setInstanceTransformArray(boxItem, unselectedInstanceMatrixArray)
3897 self.setInstanceTransformArray(selectedBoxItem, selectedInstanceMatrixArray)
3898 self.setInstanceTransformArray(shadedItem, instanceMatrixArray)
3899 self.setInstanceTransformArray(texturedItem, instanceMatrixArray)
3901 self.setInstanceTransformArray(vertexSelectionItem, instanceMatrixArray)
3902 self.setInstanceTransformArray(edgeSelectionItem, instanceMatrixArray)
3903 self.setInstanceTransformArray(faceSelectionItem, instanceMatrixArray)
3905 if activeVertexItem:
3906 self.setInstanceTransformArray(activeVertexItem, instanceMatrixArray)
3908 self.setInstanceTransformArray(activeEdgeItem, instanceMatrixArray)
3910 self.setInstanceTransformArray(activeFaceItem, instanceMatrixArray)
3915 self.fIsInstanceMode =
True
3917 self.manageIsolateSelectRenderItems(container, frameContext, instances, viewSelectedFaceInfo, shader, updateMaterial, updateGeometry)
3919 if itemsChanged
or anyMatrixChanged
or updateGeometry:
3921 omr.MRenderer.setLightsAndShadowsDirty()
3923 def manageIsolateSelectRenderItems(self, container, frameContext, instances, viewSelectedFaceInfo, shader, updateMaterial, updateGeometry):
3924 if (
not self.fMesh):
3927 meshGeom = self.fMesh.meshGeom()
3932 destination = frameContext.renderingDestination()
3933 if (destination[0] != omr.MFrameContext.k3dViewport):
3937 activeViewName = destination[1]
3939 updateViewSelectedFaces =
False
3941 if(activeViewName
not in self.fViewSelectedFaceInfoCache):
3943 if(len(viewSelectedFaceInfo) != 0):
3944 updateViewSelectedFaces =
True
3946 elif(self.fViewSelectedFaceInfoCache[activeViewName] != viewSelectedFaceInfo):
3947 updateViewSelectedFaces =
True
3952 if updateViewSelectedFaces:
3955 prevInstIdxArray = set()
3956 if (activeViewName
in self.fViewSelectedFaceInfoCache):
3957 prevInfo = self.fViewSelectedFaceInfoCache[activeViewName]
3958 for instIdx, faceIdxList
in prevInfo.iteritems():
3959 for faceIdx
in faceIdxList:
3960 if faceIdx != sViewSelectedInstanceMark:
3961 prevInstIdxArray.add(instIdx)
3964 currInstIdxArray = set()
3965 for instIdx, faceIdxList
in viewSelectedFaceInfo.iteritems():
3966 for faceIdx
in faceIdxList:
3967 if (faceIdx != sViewSelectedInstanceMark):
3968 currInstIdxArray.add(instIdx)
3971 self.fViewSelectedFaceInfoCache[activeViewName] = viewSelectedFaceInfo
3977 diffInstIdxArray = prevInstIdxArray - currInstIdxArray
3979 for instIdx
in diffInstIdxArray:
3980 namePostfix = self.sNameSeparator + str(instIdx) + self.sNameSeparator + activeViewName
3982 shadedName = self.sShadedName + namePostfix
3983 container.remove(shadedName)
3985 texturedName = self.sTexturedName + namePostfix
3986 container.remove(texturedName)
3988 faceSelectionName = self.sFaceSelectionName + namePostfix
3989 container.remove(faceSelectionName)
3993 for instIdx
in currInstIdxArray:
3994 namePostfix = self.sNameSeparator + str(instIdx) + self.sNameSeparator + activeViewName
3996 shadedName = self.sShadedName + namePostfix
3997 viewSelectedShadedItem = container.find(shadedName)
3998 if not viewSelectedShadedItem:
4000 viewSelectedShadedItem = omr.MRenderItem.create(shadedName, omr.MRenderItem.MaterialSceneItem, omr.MGeometry.kTriangles)
4001 viewSelectedShadedItem.setDrawMode(omr.MGeometry.kShaded)
4002 viewSelectedShadedItem.setExcludedFromPostEffects(
False)
4003 viewSelectedShadedItem.setCastsShadows(
True)
4004 viewSelectedShadedItem.setReceivesShadows(
True)
4006 container.add(viewSelectedShadedItem)
4008 userData = apiMeshHWSelectionUserData();
4009 userData.fMeshGeom = meshGeom;
4010 userData.fInstanceIndex = instIdx;
4011 viewSelectedShadedItem.setCustomData(userData);
4013 texturedName = self.sTexturedName + namePostfix
4014 viewSelectedTexturedItem = container.find(texturedName)
4015 if not viewSelectedTexturedItem:
4017 viewSelectedTexturedItem = omr.MRenderItem.create(texturedName, omr.MRenderItem.MaterialSceneItem, omr.MGeometry.kTriangles);
4019 viewSelectedTexturedItem.setDrawMode(omr.MGeometry.kTextured);
4020 viewSelectedTexturedItem.setExcludedFromPostEffects(
False);
4021 viewSelectedTexturedItem.setCastsShadows(
True);
4022 viewSelectedTexturedItem.setReceivesShadows(
True);
4023 container.add(viewSelectedTexturedItem);
4025 userData = apiMeshHWSelectionUserData()
4026 userData.fMeshGeom = meshGeom
4027 userData.fInstanceIndex = instIdx
4028 viewSelectedTexturedItem.setCustomData(userData)
4030 faceSelectionName = self.sFaceSelectionName + namePostfix
4031 viewSelectedFaceSelectionItem = container.find(faceSelectionName)
4032 if not viewSelectedFaceSelectionItem:
4034 viewSelectedFaceSelectionItem = omr.MRenderItem.create(faceSelectionName, omr.MRenderItem.DecorationItem, omr.MGeometry.kTriangles)
4037 viewSelectedFaceSelectionItem.setDrawMode(omr.MGeometry.kSelectionOnly)
4039 viewSelectedFaceSelectionItem.setSelectionMask(om.MSelectionMask.kSelectMeshFaces)
4041 viewSelectedFaceSelectionItem.setDepthPriority(omr.MRenderItem.sSelectionDepthPriority)
4042 viewSelectedFaceSelectionItem.setShader(self.fFaceComponentShader)
4043 container.add(viewSelectedFaceSelectionItem)
4045 userData = apiMeshHWSelectionUserData()
4046 userData.fMeshGeom = meshGeom
4047 userData.fInstanceIndex = instIdx
4048 viewSelectedFaceSelectionItem.setCustomData(userData)
4051 if (faceSelectionName
not in sViewSelectedFaceSelectionNames):
4052 omr.MDrawRegistry.registerComponentConverter(faceSelectionName, simpleComponentConverter_subsceneOverride.creatorFaceSelection)
4053 sViewSelectedFaceSelectionNames.add(faceSelectionName);
4058 for key
in self.fViewSelectedFaceInfoCache:
4060 faceInfo = self.fViewSelectedFaceInfoCache[key]
4061 isActiveView = viewName == activeViewName
4063 instIdxArray = set()
4064 for instIdx
in faceInfo:
4065 faceIdx = faceInfo[instIdx]
4066 if (faceIdx != sViewSelectedInstanceMark):
4067 instIdxArray.add(instIdx)
4069 for instIdx
in instIdxArray:
4070 namePostfix = self.sNameSeparator + str(instIdx) + self.sNameSeparator + viewName
4072 viewSelectedShadedItem = container.find(self.sShadedName + namePostfix)
4073 viewSelectedTexturedItem = container.find(self.sTexturedName + namePostfix)
4074 viewSelectedFaceSelectionItem = container.find(self.sFaceSelectionName + namePostfix)
4075 if (
not viewSelectedShadedItem
or not viewSelectedTexturedItem
or not viewSelectedFaceSelectionItem):
4079 viewSelectedShadedItem.enable(isActiveView)
4080 viewSelectedTexturedItem.enable(isActiveView)
4081 viewSelectedFaceSelectionItem.enable(isActiveView)
4084 instance = instances[instIdx]
4085 objToWorld = instance.inclusiveMatrix()
4086 viewSelectedShadedItem.setMatrix(objToWorld)
4087 viewSelectedTexturedItem.setMatrix(objToWorld)
4088 viewSelectedFaceSelectionItem.setMatrix(objToWorld)
4091 if (updateViewSelectedFaces
or updateMaterial
or updateGeometry):
4093 if (updateMaterial
or not viewSelectedShadedItem.isShaderFromNode()):
4095 userData = ShadedItemUserData(self)
4097 if shader
and viewSelectedShadedItem.setShaderFromNode(shader, instance, apiMeshSubSceneOverride.shadedItemLinkLost, userData,
True):
4098 self.fLinkLostCallbackData.append(userData);
4100 viewSelectedShadedItem.setShader(self.fShadedShader)
4102 if (updateMaterial
or not viewSelectedTexturedItem.isShaderFromNode()):
4103 userData = ShadedItemUserData(self)
4105 if shader
and viewSelectedTexturedItem.setShaderFromNode(shader, instance, apiMeshSubSceneOverride.shadedItemLinkLost, userData,
True):
4106 self.fLinkLostCallbackData.append(userData);
4108 viewSelectedTexturedItem.setShader(self.fShadedShader)
4110 shadedBuffers = omr.MVertexBufferArray()
4111 shadedBuffers.append(self.fPositionBuffer,
"positions")
4112 shadedBuffers.append(self.fNormalBuffer,
"normals")
4114 selectionBuffers = omr.MVertexBufferArray()
4115 selectionBuffers.append(self.fPositionBuffer,
"positions")
4118 for faceIdx
in xrange(meshGeom.faceCount):
4119 faceStates.append(
False)
4121 faceIds = faceInfo[instIdx]
4122 for faceIdx
in faceIds:
4123 if (faceIdx != sViewSelectedInstanceMark):
4124 faceStates[faceIdx] =
True
4127 for faceIdx
in xrange(meshGeom.faceCount):
4128 numVerts = meshGeom.face_counts[faceIdx]
4130 if faceStates[faceIdx]:
4131 numTriangles += numVerts - 2
4133 indexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4134 bufferSize = numTriangles * 3
4136 dataAddress = indexBuffer.acquire(bufferSize,
True)
4138 data = (ctypes.c_uint * bufferSize).from_address(dataAddress)
4142 for faceIdx
in xrange(meshGeom.faceCount):
4144 numVerts = meshGeom.face_counts[faceIdx]
4146 if (faceStates[faceIdx]):
4147 for v
in range(1, numVerts - 1):
4148 data[idx] = meshGeom.face_connects[base]
4150 data[idx] = meshGeom.face_connects[base + v]
4152 data[idx] = meshGeom.face_connects[base + v + 1]
4155 indexBuffer.commit(dataAddress);
4158 bounds = self.fMesh.boundingBox()
4159 self.setGeometryForRenderItem(viewSelectedShadedItem, shadedBuffers, indexBuffer, bounds)
4160 self.setGeometryForRenderItem(viewSelectedTexturedItem, shadedBuffers, indexBuffer, bounds)
4161 self.setGeometryForRenderItem(viewSelectedFaceSelectionItem, selectionBuffers, indexBuffer, bounds)
4164 userData = viewSelectedShadedItem.customData()
4165 if userData
and isinstance(userData, apiMeshHWSelectionUserData):
4166 userData.fMeshGeom = meshGeom
4168 userData = viewSelectedTexturedItem.customData()
4169 if userData
and isinstance(userData, apiMeshHWSelectionUserData):
4170 userData.fMeshGeom = meshGeom
4172 userData = viewSelectedFaceSelectionItem.customData()
4173 if userData
and isinstance(userData, apiMeshHWSelectionUserData):
4174 userData.fMeshGeom = meshGeom
4175 userData.fFaceViewSelectedStates = faceStates
4177 def rebuildGeometryBuffers(self):
4179 meshGeom = self.fMesh.meshGeom()
4182 bounds = self.fMesh.boundingBox()
4185 self.clearGeometryBuffers()
4190 totalPoints = len(meshGeom.vertices)
4191 for i
in xrange(meshGeom.faceCount):
4192 numVerts = meshGeom.face_counts[i]
4194 numTriangles += numVerts - 2
4195 totalVerts += numVerts
4198 posDesc = omr.MVertexBufferDescriptor(
"", omr.MGeometry.kPosition, omr.MGeometry.kFloat, 3)
4199 normalDesc = omr.MVertexBufferDescriptor(
"", omr.MGeometry.kNormal, omr.MGeometry.kFloat, 3)
4201 self.fPositionBuffer = omr.MVertexBuffer(posDesc)
4202 self.fNormalBuffer = omr.MVertexBuffer(normalDesc)
4203 self.fBoxPositionBuffer = omr.MVertexBuffer(posDesc)
4205 positionDataAddress = self.fPositionBuffer.acquire(totalPoints,
True)
4206 normalDataAddress = self.fNormalBuffer.acquire(totalPoints,
True)
4207 boxPositionDataAddress = self.fBoxPositionBuffer.acquire(8,
True)
4210 self.fWireIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4211 self.fBoxIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4212 self.fShadedIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4214 wireBufferDataAddress = self.fWireIndexBuffer.acquire(2*totalVerts,
True)
4215 boxBufferDataAddress = self.fBoxIndexBuffer.acquire(24,
True)
4216 shadedBufferDataAddress = self.fShadedIndexBuffer.acquire(3*numTriangles,
True)
4219 if not all((positionDataAddress, normalDataAddress, boxPositionDataAddress, wireBufferDataAddress, boxBufferDataAddress, shadedBufferDataAddress)):
4220 self.clearGeometryBuffers()
4223 positionData = ((ctypes.c_float * 3)*totalPoints).from_address(positionDataAddress)
4224 normalData = ((ctypes.c_float * 3)*totalPoints).from_address(normalDataAddress)
4225 boxPositionData = ((ctypes.c_float * 3)*8).from_address(boxPositionDataAddress)
4227 wireBufferData = (ctypes.c_uint * (2*totalVerts)).from_address(wireBufferDataAddress)
4228 boxBufferData = (ctypes.c_uint * 24).from_address(boxBufferDataAddress)
4229 shadedBufferData = ((ctypes.c_uint * 3)*numTriangles).from_address(shadedBufferDataAddress)
4232 for vid,position
in enumerate(meshGeom.vertices):
4233 positionData[vid][0] = position[0]
4234 positionData[vid][1] = position[1]
4235 positionData[vid][2] = position[2]
4237 for vid,normal
in enumerate(meshGeom.normals):
4238 normalData[vid][0] = normal[0]
4239 normalData[vid][1] = normal[1]
4240 normalData[vid][2] = normal[2]
4242 self.fPositionBuffer.commit(positionDataAddress)
4243 positionDataAddress =
None
4244 self.fNormalBuffer.commit(normalDataAddress)
4245 normalDataAddress =
None
4250 boxPositionData[0][0] = bbmin.x
4251 boxPositionData[0][1] = bbmin.y
4252 boxPositionData[0][2] = bbmin.z
4254 boxPositionData[1][0] = bbmin.x
4255 boxPositionData[1][1] = bbmin.y
4256 boxPositionData[1][2] = bbmax.z
4258 boxPositionData[2][0] = bbmax.x
4259 boxPositionData[2][1] = bbmin.y
4260 boxPositionData[2][2] = bbmax.z
4262 boxPositionData[3][0] = bbmax.x
4263 boxPositionData[3][1] = bbmin.y
4264 boxPositionData[3][2] = bbmin.z
4266 boxPositionData[4][0] = bbmin.x
4267 boxPositionData[4][1] = bbmax.y
4268 boxPositionData[4][2] = bbmin.z
4270 boxPositionData[5][0] = bbmin.x
4271 boxPositionData[5][1] = bbmax.y
4272 boxPositionData[5][2] = bbmax.z
4274 boxPositionData[6][0] = bbmax.x
4275 boxPositionData[6][1] = bbmax.y
4276 boxPositionData[6][2] = bbmax.z
4278 boxPositionData[7][0] = bbmax.x
4279 boxPositionData[7][1] = bbmax.y
4280 boxPositionData[7][2] = bbmin.z
4282 self.fBoxPositionBuffer.commit(boxPositionDataAddress)
4283 boxPositionDataAddress =
None
4289 for i
in xrange(meshGeom.faceCount):
4291 numVerts = meshGeom.face_counts[i]
4294 for v
in xrange(numVerts-1):
4295 wireBufferData[idx] = meshGeom.face_connects[vid]
4298 wireBufferData[idx] = meshGeom.face_connects[vid]
4301 wireBufferData[idx] = meshGeom.face_connects[vid]
4304 wireBufferData[idx] = meshGeom.face_connects[first]
4310 self.fWireIndexBuffer.commit(wireBufferDataAddress)
4311 wireBufferDataAddress =
None
4314 indexData = [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ]
4315 for i
in xrange(24):
4316 boxBufferData[i] = indexData[i]
4318 self.fBoxIndexBuffer.commit(boxBufferDataAddress)
4319 boxBufferDataAddress =
None
4324 for i
in xrange(meshGeom.faceCount):
4326 numVerts = meshGeom.face_counts[i]
4328 for v
in xrange(1, numVerts-1):
4329 shadedBufferData[idx][0] = meshGeom.face_connects[base]
4330 shadedBufferData[idx][1] = meshGeom.face_connects[base+v]
4331 shadedBufferData[idx][2] = meshGeom.face_connects[base+v+1]
4336 self.fShadedIndexBuffer.commit(shadedBufferDataAddress)
4337 shadedBufferDataAddress =
None
4339 def rebuildActiveComponentIndexBuffers(self):
4341 meshGeom = self.fMesh.meshGeom()
4346 self.clearActiveComponentIndexBuffers()
4349 numActiveVertices = len(self.fActiveVerticesSet)
4350 if numActiveVertices > 0:
4351 self.fActiveVerticesIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4352 activeVerticesDataAddress = self.fActiveVerticesIndexBuffer.acquire(numActiveVertices,
True)
4353 if activeVerticesDataAddress:
4354 activeVerticesData = (ctypes.c_uint*numActiveVertices).from_address(activeVerticesDataAddress)
4357 for vid
in self.fActiveVerticesSet:
4358 activeVerticesData[idx] = vid
4361 self.fActiveVerticesIndexBuffer.commit(activeVerticesDataAddress)
4362 activeVerticesDataAddress =
None
4365 numActiveEdges = len(self.fActiveEdgesSet)
4366 if numActiveEdges > 0:
4367 self.fActiveEdgesIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4368 activeEdgesDataAddress = self.fActiveEdgesIndexBuffer.acquire(2*numActiveEdges,
True)
4369 if activeEdgesDataAddress:
4370 activeEdgesData = ((ctypes.c_uint * 2)*numActiveEdges).from_address(activeEdgesDataAddress)
4376 for i
in xrange(meshGeom.faceCount):
4378 numVerts = meshGeom.face_counts[i]
4381 for v
in xrange(numVerts-1):
4382 if eid
in self.fActiveEdgesSet:
4383 activeEdgesData[idx][0] = meshGeom.face_connects[vid]
4384 activeEdgesData[idx][1] = meshGeom.face_connects[vid + 1]
4389 if eid
in self.fActiveEdgesSet:
4390 activeEdgesData[idx][0] = meshGeom.face_connects[vid]
4391 activeEdgesData[idx][1] = meshGeom.face_connects[first]
4398 self.fActiveEdgesIndexBuffer.commit(activeEdgesDataAddress)
4399 activeEdgesDataAddress =
None
4402 numActiveFaces = len(self.fActiveFacesSet)
4403 if numActiveFaces > 0:
4404 numActiveFacesTriangles = 0
4405 for i
in xrange(meshGeom.faceCount):
4406 if i
in self.fActiveFacesSet:
4407 numVerts = meshGeom.face_counts[i]
4409 numActiveFacesTriangles += numVerts - 2
4411 self.fActiveFacesIndexBuffer = omr.MIndexBuffer(omr.MGeometry.kUnsignedInt32)
4412 activeFacesDataAddress = self.fActiveFacesIndexBuffer.acquire(3*numActiveFacesTriangles,
True)
4413 if activeFacesDataAddress:
4414 activeFacesData = ((ctypes.c_uint * 3)*numActiveFacesTriangles).from_address(activeFacesDataAddress)
4418 for i
in xrange(meshGeom.faceCount):
4419 numVerts = meshGeom.face_counts[i]
4421 if i
in self.fActiveFacesSet:
4422 for v
in xrange(1, numVerts-1):
4423 activeFacesData[idx][0] = meshGeom.face_connects[vid]
4424 activeFacesData[idx][1] = meshGeom.face_connects[vid+v]
4425 activeFacesData[idx][2] = meshGeom.face_connects[vid+v+1]
4430 self.fActiveFacesIndexBuffer.commit(activeFacesDataAddress)
4431 activeFacesDataAddress =
None
4433 def clearBuffers(self):
4434 self.clearGeometryBuffers()
4435 self.clearActiveComponentIndexBuffers()
4437 def clearGeometryBuffers(self):
4438 self.fPositionBuffer =
None
4439 self.fNormalBuffer =
None
4440 self.fBoxPositionBuffer =
None
4441 self.fWireIndexBuffer =
None
4442 self.fBoxIndexBuffer =
None
4443 self.fShadedIndexBuffer =
None
4445 def clearActiveComponentIndexBuffers(self):
4446 self.fActiveVerticesIndexBuffer =
None
4447 self.fActiveEdgesIndexBuffer =
None
4448 self.fActiveFacesIndexBuffer =
None
4450 def updateSelectionGranularity(self, path, selectionContext):
4461 displayStatus = omr.MGeometryUtilities.displayStatus(path)
4462 if displayStatus == omr.MGeometryUtilities.kHilite:
4464 globalComponentMask = om.MGlobal.objectSelectionMask()
4465 if om.MGlobal.selectionMode() == om.MGlobal.kSelectComponentMode:
4466 globalComponentMask = om.MGlobal.componentSelectionMask()
4468 supportedComponentMask = om.MSelectionMask( om.MSelectionMask.kSelectMeshVerts )
4469 supportedComponentMask.addMask( om.MSelectionMask.kSelectMeshEdges )
4470 supportedComponentMask.addMask( om.MSelectionMask.kSelectMeshFaces )
4471 supportedComponentMask.addMask( om.MSelectionMask.kSelectPointsForGravity )
4473 if globalComponentMask.intersects(supportedComponentMask):
4474 selectionContext.selectionLevel = omr.MSelectionContext.kComponent
4475 elif omr.MPxSubSceneOverride.pointSnappingActive():
4476 selectionContext.selectionLevel = omr.MSelectionContext.kComponent
4478 def getSelectionPath(self, renderItem, dagPath):
4479 node = om.MFnDagNode(self.fObject)
4483 instances = node.getAllPaths()
4484 if not instances
or len(instances) == 0:
4487 dagPath.set(instances[0])
4490 def getInstancedSelectionPath(self, renderItem, intersection, dagPath):
4491 node = om.MFnDagNode(self.fObject)
4495 instances = node.getAllPaths()
4496 instanceCount = len(instances)
4497 if not instances
or instanceCount == 0:
4500 instanceId = intersection.instanceID
4503 if(instanceCount == 1
or instanceId == -1):
4505 userData = renderItem.customData()
4507 isinstance(userData, apiMeshHWSelectionUserData)
and
4508 userData.fInstanceIndex >= 0
and
4509 userData.fInstanceIndex < instanceCount):
4510 instanceId = userData.fInstanceIndex
4512 dagPath.set(instances[instanceId])
4519 elif(instanceId >=1
and instanceId <= instanceCount):
4520 view = omui.M3dView.active3dView()
4521 if view.viewIsFiltered():
4523 viewSelectedList = view.filteredObjectList()
4524 if viewSelectedList:
4525 for instIdx
in xrange(instanceCount):
4526 instance = instances[instIdx]
4527 if instance.isValid()
and instance.isVisible():
4528 intersectionList = om.MSelectionList()
4530 intersectionList.add(instance)
4531 intersectionList.intersect(viewSelectedList,
True)
4533 selectionIt = om.MItSelectionList(intersectionList)
4534 while not selectionIt.isDone():
4535 comp = selectionIt.getComponent()[1]
4538 instanceId = instanceId - 1
4540 dagPath.set(instance)
4544 for instIdx
in xrange(instanceCount):
4545 instance = instances[instIdx]
4546 if (instance.isValid()
and instance.isVisible()):
4547 instanceId = instanceId - 1
4548 if (instanceId == 0):
4549 dagPath.set(instance)
4563 class apiMeshUserData(om.MUserData):
4565 om.MUserData.__init__(self,
True)
4567 self.fNumModifications = 0
4570 def callbackDataPrint(context, renderItemList):
4571 for item
in renderItemList:
4573 path = item.sourceDagPath()
4574 print "\tITEM: '" + item.name() +
"' -- SOURCE: '" + path.fullPathName() +
"'"
4576 passCtx = context.getPassContext()
4577 passId = passCtx.passIdentifier()
4578 passSem = passCtx.passSemantics()
4579 print "\tAPI mesh drawing in pass[" + passId +
"], semantic[" + passSem +
"]"
4582 def apiMeshPreDrawCallback(context, renderItemList, shaderInstance):
4583 print "PRE-draw callback triggered for render item list with data:"
4584 callbackDataPrint(context, renderItemList)
4587 def apiMeshPostDrawCallback(context, renderItemList, shaderInstance):
4588 print "POST-draw callback triggered for render item list with data:"
4589 callbackDataPrint(context, renderItemList)
4593 class meshVertComponentConverter_geometryOverride(omr.MPxComponentConverter):
4595 omr.MPxComponentConverter.__init__(self)
4597 self.fComponent = om.MFnSingleIndexedComponent()
4598 self.fComponentObject = om.MObject.kNullObj
4601 def initialize(self, renderItem):
4603 self.fComponentObject = self.fComponent.create( om.MFn.kMeshVertComponent )
4609 selectionData = renderItem.customData()
4610 if isinstance(selectionData, apiMeshHWSelectionUserData):
4611 meshGeom = selectionData.fMeshGeom
4615 for i
in xrange(meshGeom.faceCount):
4616 numVerts = meshGeom.face_counts[i]
4618 numTriangles += numVerts - 2
4619 self.fVertices = [0]*(3*numTriangles)
4624 for faceIdx
in xrange(meshGeom.faceCount):
4626 numVerts = meshGeom.face_counts[faceIdx]
4628 for v
in xrange(1, numVerts-1):
4629 self.fVertices[idx] = meshGeom.face_connects[base]
4630 self.fVertices[idx+1] = meshGeom.face_connects[base+v]
4631 self.fVertices[idx+2] = meshGeom.face_connects[base+v+1]
4635 def addIntersection(self, intersection):
4638 rawIdx = intersection.index
4640 if rawIdx >= 0
and rawIdx < len(self.fVertices):
4641 idx = self.fVertices[rawIdx]
4642 self.fComponent.addElement(idx)
4644 def component(self):
4646 return self.fComponentObject
4648 def selectionMask(self):
4650 mask = om.MSelectionMask(om.MSelectionMask.kSelectMeshVerts)
4651 mask.addMask(om.MSelectionMask.kSelectPointsForGravity)
4656 return meshVertComponentConverter_geometryOverride()
4660 class meshEdgeComponentConverter_geometryOverride(omr.MPxComponentConverter):
4662 omr.MPxComponentConverter.__init__(self)
4664 self.fComponent = om.MFnSingleIndexedComponent()
4665 self.fComponentObject = om.MObject.kNullObj
4668 def initialize(self, renderItem):
4670 self.fComponentObject = self.fComponent.create( om.MFn.kMeshEdgeComponent )
4682 selectionData = renderItem.customData()
4683 if isinstance(selectionData, apiMeshHWSelectionUserData):
4684 meshGeom = selectionData.fMeshGeom
4688 for i
in xrange(meshGeom.faceCount):
4689 numVerts = meshGeom.face_counts[i]
4691 totalVerts += numVerts
4692 self.fEdges = [0]*(totalVerts)
4697 for faceIdx
in xrange(meshGeom.faceCount):
4699 numVerts = meshGeom.face_counts[faceIdx]
4701 for v
in xrange(numVerts):
4702 self.fEdges[idx] = edgeId
4706 def addIntersection(self, intersection):
4709 rawIdx = intersection.index
4711 if rawIdx >= 0
and rawIdx < len(self.fEdges):
4712 idx = self.fEdges[rawIdx]
4713 self.fComponent.addElement(idx)
4715 def component(self):
4717 return self.fComponentObject
4719 def selectionMask(self):
4721 return om.MSelectionMask(om.MSelectionMask.kSelectMeshEdges)
4725 return meshEdgeComponentConverter_geometryOverride()
4729 class meshFaceComponentConverter_geometryOverride(omr.MPxComponentConverter):
4731 omr.MPxComponentConverter.__init__(self)
4733 self.fComponent = om.MFnSingleIndexedComponent()
4734 self.fComponentObject = om.MObject.kNullObj
4737 def initialize(self, renderItem):
4739 self.fComponentObject = self.fComponent.create( om.MFn.kMeshPolygonComponent )
4751 selectionData = renderItem.customData()
4752 if isinstance(selectionData, apiMeshHWSelectionUserData):
4753 meshGeom = selectionData.fMeshGeom
4756 isolateSelect = renderItem.isIsolateSelectCopy()
4759 enableFaces = [0] * meshGeom.faceCount
4760 for i
in xrange(meshGeom.faceCount):
4761 enableFaces[i] =
False
4763 fnComponent = om.MFnSingleIndexedComponent( renderItem.shadingComponent() )
4764 if(fnComponent.componentType == om.MFn.kMeshPolygonComponent):
4765 faceIds = fnComponent.getElements()
4767 for i
in xrange(len(faceIds)):
4768 enableFaces[faceIds[i]] =
True
4772 for i
in xrange(meshGeom.faceCount):
4773 numVerts = meshGeom.face_counts[i]
4775 if(
not isolateSelect
or enableFaces[i]):
4776 numTriangles += numVerts - 2
4778 self.fFaces = [0]*numTriangles
4782 for faceIdx
in xrange(meshGeom.faceCount):
4784 numVerts = meshGeom.face_counts[faceIdx]
4786 if(
not isolateSelect
or enableFaces[faceIdx]):
4787 for v
in xrange(1, numVerts-1):
4788 self.fFaces[idx] = faceIdx
4793 def addIntersection(self, intersection):
4796 rawIdx = intersection.index
4798 if rawIdx >= 0
and rawIdx < len(self.fFaces):
4799 idx = self.fFaces[rawIdx]
4800 self.fComponent.addElement(idx)
4802 def component(self):
4804 return self.fComponentObject
4806 def selectionMask(self):
4808 return om.MSelectionMask(om.MSelectionMask.kSelectMeshFaces)
4812 return meshFaceComponentConverter_geometryOverride()
4814 class apiMeshGeometryOverride(omr.MPxGeometryOverride):
4816 sWireframeItemName =
"apiMeshWire"
4817 sShadedTemplateItemName =
"apiMeshShadedTemplateWire"
4818 sSelectedWireframeItemName =
"apiMeshSelectedWireFrame"
4819 sVertexItemName =
"apiMeshVertices"
4820 sEdgeSelectionItemName =
"apiMeshEdgeSelection"
4821 sFaceSelectionItemName =
"apiMeshFaceSelection"
4822 sActiveVertexItemName =
"apiMeshActiveVertices"
4823 sVertexIdItemName =
"apiMeshVertexIds"
4824 sVertexPositionItemName =
"apiMeshVertexPositions"
4825 sShadedModeFaceCenterItemName =
"apiMeshFaceCenterInShadedMode"
4826 sWireframeModeFaceCenterItemName =
"apiMeshFaceCenterInWireframeMode"
4827 sShadedProxyItemName =
"apiShadedProxy"
4828 sAffectedEdgeItemName =
"apiMeshAffectedEdges"
4829 sAffectedFaceItemName =
"apiMeshAffectedFaces"
4830 sActiveVertexStreamName =
"apiMeshSharedVertexStream"
4831 sFaceCenterStreamName =
"apiMeshFaceCenterStream"
4835 return apiMeshGeometryOverride(obj)
4837 def __init__(self, obj):
4838 omr.MPxGeometryOverride.__init__(self, obj)
4840 node = om.MFnDependencyNode(obj)
4841 self.fMesh = node.userNode()
4842 self.fMeshGeom =
None
4843 self.fColorRemapTexture =
None
4845 self.fActiveVertices = om.MIntArray()
4846 self.fActiveVerticesSet = set()
4847 self.fActiveEdgesSet = set()
4848 self.fActiveFacesSet = set()
4849 self.fCastsShadows =
False
4850 self.fReceivesShadows =
False
4856 self.fDrawSharedActiveVertices =
True
4858 self.fDrawActiveVerticesWithRamp =
False
4859 self.fLinearSampler =
None
4862 self.fDrawFaceCenters =
True
4864 if self.fDrawActiveVerticesWithRamp:
4865 self.fDrawFaceCenters =
False
4870 self.fUseCustomColors =
False
4881 self.fProxyShader = omr.MShaderManager.k3dCPVThickDashLineShader
4885 self.fInternalItems_NoShadowCast =
False
4886 self.fInternalItems_NoShadowReceive =
False
4887 self.fInternalItems_NoPostEffects =
False
4891 self.fExternalItems_NoShadowCast =
False
4892 self.fExternalItems_NoShadowReceive =
False
4893 self.fExternalItemsNonTri_NoShadowCast =
False
4894 self.fExternalItemsNonTri_NoShadowReceive =
False
4898 self.fExternalItems_NoPostEffects =
True
4899 self.fExternalItemsNonTri_NoPostEffects =
True
4903 self.fMeshGeom =
None
4905 if self.fColorRemapTexture:
4906 textureMgr = omr.MRenderer.getTextureManager()
4908 textureMgr.releaseTexture(self.fColorRemapTexture)
4909 self.fColorRemapTexture =
None
4911 if self.fLinearSampler:
4912 omr.MStateManager.releaseSamplerState(self.fLinearSampler)
4913 self.fLinearSampler =
None
4915 def supportedDrawAPIs(self):
4917 return omr.MRenderer.kOpenGL | omr.MRenderer.kDirectX11 | omr.MRenderer.kOpenGLCoreProfile
4922 self.fActiveVertices.clear()
4923 self.fActiveVerticesSet = set()
4924 self.fActiveEdgesSet = set()
4925 self.fActiveFacesSet = set()
4927 self.fMeshGeom = self.fMesh.meshGeom()
4929 if self.fMeshGeom
and self.fMesh.hasActiveComponents():
4930 activeComponents = self.fMesh.activeComponents()
4931 if len(activeComponents) > 0:
4932 fnComponent = om.MFnSingleIndexedComponent( activeComponents[0] )
4933 if fnComponent.elementCount > 0:
4934 activeIds = fnComponent.getElements()
4936 if fnComponent.componentType == om.MFn.kMeshVertComponent:
4937 self.fActiveVertices = activeIds
4938 self.fActiveVerticesSet = set(activeIds)
4940 elif fnComponent.componentType == om.MFn.kMeshEdgeComponent:
4941 self.fActiveEdgesSet = set(activeIds)
4943 elif fnComponent.componentType == om.MFn.kMeshPolygonComponent:
4944 self.fActiveFacesSet = set(activeIds)
4946 def updateRenderItems(self, path, list):
4950 shaderMgr = omr.MRenderer.getShaderManager()
4954 dagNode = om.MFnDagNode(path)
4955 castsShadowsPlug = dagNode.findPlug(
"castsShadows",
False)
4956 self.fCastsShadows = castsShadowsPlug.asBool()
4957 receiveShadowsPlug = dagNode.findPlug(
"receiveShadows",
False)
4958 self.fReceivesShadows = receiveShadowsPlug.asBool()
4961 self.updateDormantAndTemplateWireframeItems(path, list, shaderMgr)
4962 self.updateActiveWireframeItem(path, list, shaderMgr)
4965 self.updateDormantVerticesItem(path, list, shaderMgr)
4966 self.updateActiveVerticesItem(path, list, shaderMgr)
4969 self.updateVertexNumericItems(path, list, shaderMgr)
4972 if self.fDrawFaceCenters:
4973 self.updateWireframeModeFaceCenterItem(path, list, shaderMgr)
4974 self.updateShadedModeFaceCenterItem(path, list, shaderMgr)
4977 self.updateAffectedComponentItems(path, list, shaderMgr)
4980 self.updateSelectionComponentItems(path, list, shaderMgr)
4983 self.updateProxyShadedItem(path, list, shaderMgr)
4989 testShadedOverrides = self.fInternalItems_NoShadowCast
or self.fInternalItems_NoShadowReceive
or self.fInternalItems_NoPostEffects
4990 if testShadedOverrides:
4995 drawMode = item.drawMode()
4996 if drawMode == omr.MGeometry.kShaded
or drawMode == omr.MGeometry.kTextured:
4997 if item.name() != self.sShadedTemplateItemName:
4998 item.setCastsShadows(
not self.fInternalItems_NoShadowCast
and self.fCastsShadows )
4999 item.setReceivesShadows(
not self.fInternalItems_NoShadowReceive
and self.fReceivesShadows )
5000 item.setExcludedFromPostEffects( self.fInternalItems_NoPostEffects )
5002 def populateGeometry(self, requirements, renderItems, data):
5013 debugPopulateGeometry =
False
5014 if debugPopulateGeometry:
5015 print "> Begin populate geometry"
5018 activeVertexCount = len(self.fActiveVertices)
5023 for i
in xrange(self.fMeshGeom.faceCount):
5024 numVerts = self.fMeshGeom.face_counts[i]
5026 numTriangles += numVerts - 2
5027 totalVerts += numVerts
5030 self.updateGeometryRequirements(requirements, data, activeVertexCount, totalVerts, debugPopulateGeometry)
5033 wireIndexBuffer =
None
5035 for item
in renderItems:
5044 itemBuffers = item.requiredVertexBuffers()
5045 for desc
in itemBuffers:
5046 print "Buffer Required for Item '" + item.name() +
"':"
5047 print "\tBufferName: " + desc.name
5048 print "\tDataType: " + omr.MGeometry.dataTypeString(desc.dataType) +
" (dimension " + str(desc.dimension) +
")"
5049 print "\tSemantic: " + omr.MGeometry.semanticString(desc.semantic)
5054 myCustomData = item.customData()
5055 if isinstance(myCustomData, apiMeshUserData):
5056 print "Custom data '" + myCustomData.fMessage +
"', modified count='" + str(myCustomData.fNumModifications) +
"'"
5058 print "No custom data"
5062 if item.name() == self.sActiveVertexItemName:
5063 self.updateIndexingForVertices( item, data, numTriangles, activeVertexCount, debugPopulateGeometry)
5067 if self.fDrawFaceCenters
and (item.name() == self.sShadedModeFaceCenterItemName
or item.name() == self.sWireframeModeFaceCenterItemName):
5068 self.updateIndexingForFaceCenters( item, data, debugPopulateGeometry)
5072 elif item.name() == self.sVertexItemName
or item.name() == self.sVertexIdItemName
or item.name() == self.sVertexPositionItemName:
5073 self.updateIndexingForDormantVertices( item, data, numTriangles )
5077 elif item.name() == self.sWireframeItemName
or item.name() == self.sShadedTemplateItemName
or item.name() == self.sSelectedWireframeItemName
or (item.primitive() != omr.MGeometry.kTriangles
and item.name() == self.sShadedProxyItemName):
5078 self.updateIndexingForWireframeItems(wireIndexBuffer, item, data, totalVerts)
5084 elif item.name() == self.sAffectedEdgeItemName:
5085 self.updateIndexingForEdges(item, data, totalVerts,
True)
5086 elif item.name() == self.sEdgeSelectionItemName:
5087 self.updateIndexingForEdges(item, data, totalVerts,
False)
5093 elif item.name() == self.sAffectedFaceItemName:
5094 self.updateIndexingForFaces(item, data, numTriangles,
True)
5095 elif item.name() == self.sFaceSelectionItemName:
5096 self.updateIndexingForFaces(item, data, numTriangles,
False)
5100 elif item.primitive() == omr.MGeometry.kTriangles:
5101 self.updateIndexingForShadedTriangles(item, data, numTriangles)
5103 if debugPopulateGeometry:
5104 print "> End populate geometry"
5107 self.fMeshGeom =
None
5108 self.fActiveVertices.clear()
5109 self.fActiveVerticesSet = set()
5110 self.fActiveEdgesSet = set()
5111 self.fActiveFacesSet = set()
5113 def updateSelectionGranularity(self, path, selectionContext):
5125 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5126 if displayStatus == omr.MGeometryUtilities.kHilite:
5128 globalComponentMask = om.MGlobal.objectSelectionMask()
5129 if om.MGlobal.selectionMode() == om.MGlobal.kSelectComponentMode:
5130 globalComponentMask = om.MGlobal.componentSelectionMask()
5132 supportedComponentMask = om.MSelectionMask( om.MSelectionMask.kSelectMeshVerts )
5133 supportedComponentMask.addMask( om.MSelectionMask.kSelectMeshEdges )
5134 supportedComponentMask.addMask( om.MSelectionMask.kSelectMeshFaces )
5135 supportedComponentMask.addMask( om.MSelectionMask.kSelectPointsForGravity )
5137 if globalComponentMask.intersects(supportedComponentMask):
5138 selectionContext.selectionLevel = omr.MSelectionContext.kComponent
5139 elif omr.MPxGeometryOverride.pointSnappingActive():
5140 selectionContext.selectionLevel = omr.MSelectionContext.kComponent
5142 def printShader(self, shader):
5147 params = shader.parameterList()
5148 print "DEBUGGING SHADER, BEGIN PARAM LIST OF LENGTH " + str(len(params))
5150 for param
in params:
5151 paramType = shader.parameterType(param)
5152 isArray = shader.isArrayParameter(param)
5154 typeAsStr =
"Unknown"
5155 if paramType == omr.MShaderInstance.kInvalid:
5156 typeAsStr =
"Invalid"
5157 elif paramType == omr.MShaderInstance.kBoolean:
5158 typeAsStr =
"Boolean"
5159 elif paramType == omr.MShaderInstance.kInteger:
5160 typeAsStr =
"Integer"
5161 elif paramType == omr.MShaderInstance.kFloat:
5163 elif paramType == omr.MShaderInstance.kFloat2:
5164 typeAsStr =
"Float2"
5165 elif paramType == omr.MShaderInstance.kFloat3:
5166 typeAsStr =
"Float3"
5167 elif paramType == omr.MShaderInstance.kFloat4:
5168 typeAsStr =
"Float4"
5169 elif paramType == omr.MShaderInstance.kFloat4x4Row:
5170 typeAsStr =
"Float4x4Row"
5171 elif paramType == omr.MShaderInstance.kFloat4x4Col:
5172 typeAsStr =
"Float4x4Col"
5173 elif paramType == omr.MShaderInstance.kTexture1:
5174 typeAsStr =
"1D Texture"
5175 elif paramType == omr.MShaderInstance.kTexture2:
5176 typeAsStr =
"2D Texture"
5177 elif paramType == omr.MShaderInstance.kTexture3:
5178 typeAsStr =
"3D Texture"
5179 elif paramType == omr.MShaderInstance.kTextureCube:
5180 typeAsStr =
"Cube Texture"
5181 elif paramType == omr.MShaderInstance.kSampler:
5182 typeAsStr =
"Sampler"
5184 print "ParamName='" + param +
"', ParamType='" + typeAsStr +
"', IsArrayParameter:'" + str(isArray) +
"'"
5186 print "END PARAM LIST"
5188 def setSolidColor(self, shaderInstance, defaultColor, customColor=None):
5191 color = defaultColor
5192 if self.fUseCustomColors
and customColor:
5195 shaderInstance.setParameter(
"solidColor", color)
5199 def setSolidPointSize(self, shaderInstance, size):
5203 shaderInstance.setParameter(
"pointSize", [size, size])
5207 def setLineWidth(self, shaderInstance, width):
5211 shaderInstance.setParameter(
"lineWidth", [width, width])
5215 def enableActiveComponentDisplay(self, path):
5227 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5228 if displayStatus == omr.MGeometryUtilities.kHilite
or displayStatus == omr.MGeometryUtilities.kActiveComponent:
5234 if path.isTemplated():
5240 def updateDormantAndTemplateWireframeItems(self, path, list, shaderMgr):
5252 dormantColor = [ 0.0, 0.0, 1.0, 1.0 ]
5253 templateColor = [ 0.45, 0.45, 0.45, 1.0 ]
5254 activeTemplateColor = [ 1.0, 0.5, 0.5, 1.0 ]
5263 wireframeItem =
None
5264 index = list.indexOf(self.sWireframeItemName)
5266 wireframeItem = omr.MRenderItem.create( self.sWireframeItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
5267 wireframeItem.setDrawMode(omr.MGeometry.kWireframe)
5271 wireframeItem.setDepthPriority( omr.MRenderItem.sDormantWireDepthPriority )
5273 list.append(wireframeItem)
5278 preCb = apiMeshPreDrawCallback
5279 postCb = apiMeshPostDrawCallback
5281 shader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader, preCb, postCb)
5284 wireframeItem.setShader(shader)
5288 self.printShader( shader )
5291 shaderMgr.releaseShader(shader)
5293 wireframeItem = list[index]
5297 shadedTemplateItem =
None
5298 index = list.indexOf(self.sShadedTemplateItemName)
5300 shadedTemplateItem = omr.MRenderItem.create( self.sShadedTemplateItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
5301 shadedTemplateItem.setDrawMode(omr.MGeometry.kAll)
5305 shadedTemplateItem.setDepthPriority( omr.MRenderItem.sDormantWireDepthPriority )
5307 list.append(shadedTemplateItem)
5309 shader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader)
5312 shadedTemplateItem.setShader(shader)
5316 self.printShader( shader )
5319 shaderMgr.releaseShader(shader)
5321 shadedTemplateItem = list[index]
5324 shadedTemplateItem.setCastsShadows(
not self.fExternalItemsNonTri_NoShadowCast )
5325 shadedTemplateItem.setReceivesShadows(
not self.fExternalItemsNonTri_NoShadowReceive )
5326 shadedTemplateItem.setExcludedFromPostEffects( self.fExternalItemsNonTri_NoPostEffects )
5328 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5329 wireColor = omr.MGeometryUtilities.wireframeColor(path)
5334 shader = wireframeItem.getShader()
5336 if displayStatus == omr.MGeometryUtilities.kTemplate:
5337 self.setSolidColor( shader, wireColor, templateColor)
5338 wireframeItem.enable(
True)
5340 elif displayStatus == omr.MGeometryUtilities.kActiveTemplate:
5341 self.setSolidColor( shader, wireColor, activeTemplateColor)
5342 wireframeItem.enable(
True)
5344 elif displayStatus == omr.MGeometryUtilities.kDormant:
5345 self.setSolidColor( shader, wireColor, dormantColor)
5346 wireframeItem.enable(
True)
5348 elif displayStatus == omr.MGeometryUtilities.kActiveAffected:
5349 theColor = [ 0.5, 0.0, 1.0, 1.0 ]
5350 self.setSolidColor( shader, wireColor, theColor)
5351 wireframeItem.enable(
True)
5354 wireframeItem.enable(
False)
5358 if shadedTemplateItem:
5359 isTemplate = path.isTemplated()
5360 shader = shadedTemplateItem.getShader()
5362 if displayStatus == omr.MGeometryUtilities.kTemplate:
5363 self.setSolidColor( shader, wireColor, templateColor)
5364 shadedTemplateItem.enable(isTemplate)
5366 elif displayStatus == omr.MGeometryUtilities.kActiveTemplate:
5367 self.setSolidColor( shader, wireColor, activeTemplateColor)
5368 shadedTemplateItem.enable(isTemplate)
5370 elif displayStatus == omr.MGeometryUtilities.kDormant:
5371 self.setSolidColor( shader, wireColor, dormantColor)
5372 shadedTemplateItem.enable(isTemplate)
5375 shadedTemplateItem.enable(
False)
5377 def updateActiveWireframeItem(self, path, list, shaderMgr):
5382 index = list.indexOf(self.sSelectedWireframeItemName)
5384 selectItem = omr.MRenderItem.create(self.sSelectedWireframeItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
5385 selectItem.setDrawMode(omr.MGeometry.kAll)
5390 selectItem.setDepthPriority( omr.MRenderItem.sActiveWireDepthPriority )
5391 list.append(selectItem)
5396 shaderId = omr.MShaderManager.k3dSolidShader
5398 shaderId = omr.MShaderManager.k3dThickLineShader
5400 shader = shaderMgr.getStockShader(shaderId)
5403 selectItem.setShader(shader)
5405 shaderMgr.releaseShader(shader)
5407 selectItem = list[index]
5411 shader = selectItem.getShader()
5413 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5414 wireColor = omr.MGeometryUtilities.wireframeColor(path)
5416 if displayStatus == omr.MGeometryUtilities.kLead:
5417 theColor = [ 0.0, 0.8, 0.0, 1.0 ]
5418 self.setSolidColor( shader, wireColor, theColor)
5419 selectItem.enable(
True)
5421 elif displayStatus == omr.MGeometryUtilities.kActive:
5422 theColor = [ 1.0, 1.0, 1.0, 1.0 ]
5423 self.setSolidColor( shader, wireColor, theColor)
5424 selectItem.enable(
True)
5426 elif displayStatus == omr.MGeometryUtilities.kHilite
or displayStatus == omr.MGeometryUtilities.kActiveComponent:
5427 theColor = [ 0.0, 0.5, 0.7, 1.0 ]
5428 self.setSolidColor( shader, wireColor, theColor)
5429 selectItem.enable(
True)
5432 selectItem.enable(
False)
5435 myCustomData = selectItem.customData()
5436 if not myCustomData:
5438 myCustomData = apiMeshUserData()
5439 myCustomData.fMessage =
"I'm custom data!"
5440 selectItem.setCustomData(myCustomData)
5443 myCustomData.fNumModifications += 1
5445 def updateWireframeModeFaceCenterItem(self, path, list, shaderMgr):
5449 wireframeModeFaceCenterItem =
None
5450 index = list.indexOf(self.sWireframeModeFaceCenterItemName)
5452 wireframeModeFaceCenterItem = omr.MRenderItem.create(self.sWireframeModeFaceCenterItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5453 wireframeModeFaceCenterItem.setDrawMode(omr.MGeometry.kWireframe)
5454 wireframeModeFaceCenterItem.setDepthPriority( omr.MRenderItem.sActiveWireDepthPriority )
5456 list.append(wireframeModeFaceCenterItem)
5458 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dFatPointShader )
5462 self.setSolidPointSize( shader, pointSize )
5464 wireframeModeFaceCenterItem.setShader(shader, self.sFaceCenterStreamName )
5467 shaderMgr.releaseShader(shader)
5469 wireframeModeFaceCenterItem = list[index]
5471 if wireframeModeFaceCenterItem:
5472 shader = wireframeModeFaceCenterItem.getShader()
5475 theColor = [ 0.0, 0.0, 1.0, 1.0 ]
5476 self.setSolidColor( shader, theColor )
5479 isTemplate = path.isTemplated()
5480 wireframeModeFaceCenterItem.enable(
not isTemplate )
5482 def updateShadedModeFaceCenterItem(self, path, list, shaderMgr):
5486 shadedModeFaceCenterItem =
None
5487 index = list.indexOf(self.sShadedModeFaceCenterItemName)
5489 shadedModeFaceCenterItem = omr.MRenderItem.create( self.sShadedModeFaceCenterItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5490 shadedModeFaceCenterItem.setDrawMode(omr.MGeometry.kShaded | omr.MGeometry.kTextured)
5492 shadedModeFaceCenterItem.setDepthPriority(omr.MRenderItem.sActivePointDepthPriority)
5494 list.append(shadedModeFaceCenterItem)
5496 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dFatPointShader )
5500 self.setSolidPointSize( shader, pointSize )
5502 shadedModeFaceCenterItem.setShader(shader, self.sFaceCenterStreamName )
5505 shaderMgr.releaseShader(shader)
5507 shadedModeFaceCenterItem = list[index]
5509 if shadedModeFaceCenterItem:
5510 shadedModeFaceCenterItem.setExcludedFromPostEffects(
True)
5512 shader = shadedModeFaceCenterItem.getShader()
5513 wireColor = omr.MGeometryUtilities.wireframeColor(path)
5517 self.setSolidColor( shader, wireColor )
5519 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5520 if displayStatus == omr.MGeometryUtilities.kActive
or displayStatus == omr.MGeometryUtilities.kLead
or displayStatus == omr.MGeometryUtilities.kActiveComponent
or displayStatus == omr.MGeometryUtilities.kLive
or displayStatus == omr.MGeometryUtilities.kHilite:
5521 shadedModeFaceCenterItem.enable(
True)
5524 shadedModeFaceCenterItem.enable(
False)
5526 def updateDormantVerticesItem(self, path, list, shaderMgr):
5531 index = list.indexOf(self.sVertexItemName)
5533 vertexItem = omr.MRenderItem.create(self.sVertexItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5536 vertexItem.setDrawMode(omr.MGeometry.kAll)
5539 mask = om.MSelectionMask(om.MSelectionMask.kSelectMeshVerts)
5540 mask.addMask(om.MSelectionMask.kSelectPointsForGravity)
5541 vertexItem.setSelectionMask( mask )
5546 vertexItem.setDepthPriority( omr.MRenderItem.sDormantPointDepthPriority )
5547 list.append(vertexItem)
5549 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dFatPointShader )
5553 self.setSolidPointSize( shader, pointSize )
5556 vertexItem.setShader(shader)
5559 shaderMgr.releaseShader(shader)
5561 vertexItem = list[index]
5564 shader = vertexItem.getShader()
5566 theColor = [ 0.0, 0.0, 1.0, 1.0 ]
5567 self.setSolidColor( shader, theColor )
5569 displayStatus = omr.MGeometryUtilities.displayStatus(path)
5573 if displayStatus == omr.MGeometryUtilities.kHilite
or omr.MPxGeometryOverride.pointSnappingActive():
5577 if path.isTemplated():
5578 vertexItem.enable(
False)
5580 vertexItem.enable(
True)
5582 vertexItem.enable(
False)
5584 mySelectionData = vertexItem.customData()
5585 if not isinstance(mySelectionData, apiMeshHWSelectionUserData):
5587 mySelectionData = apiMeshHWSelectionUserData()
5588 vertexItem.setCustomData(mySelectionData)
5590 mySelectionData.fMeshGeom = self.fMeshGeom
5592 def updateActiveVerticesItem(self, path, list, shaderMgr):
5597 index = list.indexOf(self.sActiveVertexItemName)
5599 activeItem = omr.MRenderItem.create(self.sActiveVertexItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5600 activeItem.setDrawMode(omr.MGeometry.kAll)
5603 activeItem.setDepthPriority( omr.MRenderItem.sActivePointDepthPriority )
5604 list.append(activeItem)
5606 shaderId = omr.MShaderManager.k3dFatPointShader
5607 if self.fDrawActiveVerticesWithRamp:
5608 shaderId = omr.MShaderManager.k3dColorLookupFatPointShader
5610 shader = shaderMgr.getStockShader( shaderId )
5614 self.setSolidPointSize( shader, pointSize )
5618 if self.fDrawActiveVerticesWithRamp:
5619 textureMgr = omr.MRenderer.getTextureManager()
5622 if not self.fColorRemapTexture:
5624 colorArray = [ 1.0, 0.0, 0.0, 1.0,
5626 0.0, 0.0, 1.0, 1.0 ]
5629 textureDesc = omr.MTextureDescription()
5630 textureDesc.setToDefault2DTexture()
5631 textureDesc.fWidth = arrayLen
5632 textureDesc.fHeight = 1
5633 textureDesc.fDepth = 1
5634 textureDesc.fBytesPerSlice = textureDesc.fBytesPerRow = 24*arrayLen
5635 textureDesc.fMipmaps = 1
5636 textureDesc.fArraySlices = 1
5637 textureDesc.fTextureType = omr.MRenderer.kImage1D
5638 textureDesc.fFormat = omr.MRenderer.kR32G32B32A32_FLOAT
5639 self.fColorRemapTexture = textureMgr.acquireTexture(
"", textureDesc, colorArray,
False)
5641 if not self.fLinearSampler:
5642 samplerDesc = omr.MSamplerStateDesc()
5643 samplerDesc.addressU = omr.MSamplerState.kTexClamp
5644 samplerDesc.addressV = omr.MSamplerState.kTexClamp
5645 samplerDesc.addressW = omr.MSamplerState.kTexClamp
5646 samplerDesc.filter = omr.MSamplerState.kMinMagMipLinear
5647 fLinearSampler = omr.MStateManager.acquireSamplerState(samplerDesc)
5649 if self.fColorRemapTexture
and self.fLinearSampler:
5651 shader.setParameter(
"map", self.fColorRemapTexture)
5652 shader.setParameter(
"samp", self.fLinearSampler)
5656 rampValueRange = om.MFloatVector(0.0, 1.0)
5657 shader.setParameter(
"UVRange", rampValueRange)
5661 if self.fDrawSharedActiveVertices:
5662 activeItem.setShader(shader, self.sActiveVertexStreamName)
5664 activeItem.setShader(shader,
None)
5667 shaderMgr.releaseShader(shader)
5670 activeItem = list[index]
5673 shader = activeItem.getShader()
5676 theColor = [ 1.0, 1.0, 0.0, 1.0 ]
5677 self.setSolidColor( shader, theColor )
5679 enable = (bool(self.fActiveVerticesSet)
and self.enableActiveComponentDisplay(path))
5680 activeItem.enable( enable )
5682 def updateVertexNumericItems(self, path, list, shaderMgr):
5686 enableNumericDisplay =
False
5691 index = list.indexOf(self.sVertexIdItemName)
5693 vertexItem = omr.MRenderItem.create( self.sVertexIdItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5694 vertexItem.setDrawMode(omr.MGeometry.kAll)
5695 vertexItem.setDepthPriority( omr.MRenderItem.sDormantPointDepthPriority )
5696 list.append(vertexItem)
5699 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dIntegerNumericShader )
5702 vertexItem.setShader(shader, self.sVertexIdItemName)
5703 shaderMgr.releaseShader(shader)
5705 vertexItem = list[index]
5708 shader = vertexItem.getShader()
5711 theColor = [ 1.0, 1.0, 0.0, 1.0 ]
5712 self.setSolidColor( shader, theColor )
5714 vertexItem.enable(enableNumericDisplay)
5719 index = list.indexOf(self.sVertexPositionItemName)
5721 vertexItem = omr.MRenderItem.create( self.sVertexPositionItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kPoints)
5722 vertexItem.setDrawMode(omr.MGeometry.kAll)
5723 vertexItem.setDepthPriority( omr.MRenderItem.sDormantPointDepthPriority )
5724 list.append(vertexItem)
5727 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dFloat3NumericShader )
5730 vertexItem.setShader(shader, self.sVertexPositionItemName)
5731 shaderMgr.releaseShader(shader)
5733 vertexItem = list[index]
5736 shader = vertexItem.getShader()
5739 theColor = [ 0.0, 1.0, 1.0, 1.0 ]
5740 self.setSolidColor( shader, theColor)
5742 vertexItem.enable(enableNumericDisplay)
5744 def updateAffectedComponentItems(self, path, list, shaderMgr):
5751 componentItem =
None
5752 index = list.indexOf(self.sAffectedEdgeItemName)
5754 componentItem = omr.MRenderItem.create( self.sAffectedEdgeItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
5755 componentItem.setDrawMode(omr.MGeometry.kAll)
5759 componentItem.setDepthPriority( omr.MRenderItem.sActiveLineDepthPriority )
5760 list.append(componentItem)
5762 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dThickLineShader )
5766 self.setLineWidth( shader, lineSize )
5769 componentItem.setShader(shader,
None)
5772 shaderMgr.releaseShader(shader)
5774 componentItem = list[index]
5777 shader = componentItem.getShader()
5780 theColor = [ 1.0, 1.0, 1.0, 1.0 ]
5781 self.setSolidColor( shader, theColor )
5783 enable = ((bool(self.fActiveVerticesSet)
or bool(self.fActiveEdgesSet))
and self.enableActiveComponentDisplay(path))
5784 componentItem.enable( enable )
5790 componentItem =
None
5791 index = list.indexOf(self.sAffectedFaceItemName)
5793 componentItem = omr.MRenderItem.create( self.sAffectedFaceItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kTriangles)
5794 componentItem.setDrawMode(omr.MGeometry.kAll)
5797 componentItem.setDepthPriority( omr.MRenderItem.sDormantWireDepthPriority )
5800 componentItem.setAllowIsolateSelectCopy(
True);
5802 list.append(componentItem)
5804 shader = shaderMgr.getStockShader( omr.MShaderManager.k3dStippleShader )
5807 componentItem.setShader(shader,
None)
5810 shaderMgr.releaseShader(shader)
5812 componentItem = list[index]
5815 shader = componentItem.getShader()
5818 theColor = [ 1.0, 1.0, 1.0, 1.0 ]
5819 self.setSolidColor( shader, theColor )
5821 enable = ((bool(self.fActiveVerticesSet)
or bool(self.fActiveFacesSet))
and self.enableActiveComponentDisplay(path))
5822 componentItem.enable( enable )
5824 def updateSelectionComponentItems(self, path, list, shaderMgr):
5839 selectionItem =
None
5840 index = list.indexOf(self.sEdgeSelectionItemName)
5842 selectionItem = omr.MRenderItem.create( self.sEdgeSelectionItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kLines)
5845 selectionItem.setDrawMode(omr.MGeometry.kSelectionOnly)
5848 selectionItem.setSelectionMask( om.MSelectionMask.kSelectMeshEdges )
5851 selectionItem.setDepthPriority( omr.MRenderItem.sSelectionDepthPriority )
5852 list.append(selectionItem)
5854 shader = shaderMgr.getStockShader(omr.MShaderManager.k3dThickLineShader)
5857 selectionItem.setShader(shader,
None)
5860 shaderMgr.releaseShader(shader)
5862 selectionItem = list[index]
5865 selectionItem.enable(
True)
5867 mySelectionData = selectionItem.customData()
5868 if not isinstance(mySelectionData, apiMeshHWSelectionUserData):
5870 mySelectionData = apiMeshHWSelectionUserData()
5871 selectionItem.setCustomData(mySelectionData)
5873 mySelectionData.fMeshGeom = self.fMeshGeom
5877 index = list.indexOf(self.sFaceSelectionItemName)
5879 selectionItem = omr.MRenderItem.create( self.sFaceSelectionItemName, omr.MRenderItem.DecorationItem, omr.MGeometry.kTriangles)
5882 selectionItem.setDrawMode(omr.MGeometry.kSelectionOnly)
5885 selectionItem.setSelectionMask( om.MSelectionMask.kSelectMeshFaces )
5888 selectionItem.setDepthPriority( omr.MRenderItem.sSelectionDepthPriority )
5891 selectionItem.setAllowIsolateSelectCopy(
True);
5893 list.append(selectionItem)
5895 shader = shaderMgr.getStockShader(omr.MShaderManager.k3dSolidShader)
5898 selectionItem.setShader(shader,
None)
5901 shaderMgr.releaseShader(shader)
5903 selectionItem = list[index]
5906 selectionItem.enable(
True)
5908 mySelectionData = selectionItem.customData()
5909 if not isinstance(mySelectionData, apiMeshHWSelectionUserData):
5911 mySelectionData = apiMeshHWSelectionUserData()
5912 selectionItem.setCustomData(mySelectionData)
5914 mySelectionData.fMeshGeom = self.fMeshGeom
5916 def updateProxyShadedItem(self, path, list, shaderMgr):
5921 dormantColor = [ 0.0, 0.0, 1.0, 1.0 ]
5922 templateColor = [ 0.45, 0.45, 0.45, 1.0 ]
5923 activeTemplateColor = [ 1.0, 0.5, 0.5, 1.0 ]
5930 raiseAboveShaded =
True
5931 shadedDrawMode = omr.MGeometry.kShaded | omr.MGeometry.kTextured
5934 useFragmentShader = self.fProxyShader < 0
5935 if not useFragmentShader:
5936 shadedDrawMode |= omr.MGeometry.kWireframe
5941 itemType = omr.MRenderItem.NonMaterialSceneItem
5942 primitive = omr.MGeometry.kLines
5943 filledProxy = useFragmentShader
or self.fProxyShader == omr.MShaderManager.k3dStippleShader
5945 itemType = omr.MRenderItem.MaterialSceneItem
5946 primitive = omr.MGeometry.kTriangles
5948 depthPriority = omr.MRenderItem.sDormantWireDepthPriority
5949 if raiseAboveShaded:
5950 depthPriority = omr.MRenderItem.sActiveWireDepthPriority
5953 index = list.indexOf(self.sShadedProxyItemName)
5955 proxyItem = omr.MRenderItem.create( self.sShadedProxyItemName, itemType, primitive)
5956 proxyItem.setDrawMode(shadedDrawMode)
5957 proxyItem.setDepthPriority( depthPriority )
5959 proxyItem.setCastsShadows(
not self.fExternalItems_NoShadowCast
and self.fCastsShadows )
5960 proxyItem.setReceivesShadows(
not self.fExternalItems_NoShadowReceive
and self.fReceivesShadows )
5961 proxyItem.setExcludedFromPostEffects( self.fExternalItems_NoPostEffects )
5963 list.append(proxyItem)
5968 if useFragmentShader:
5969 shader = shaderMgr.getFragmentShader(
"mayaLambertSurface",
"outSurfaceFinal",
True)
5970 sBlue = [ 0.4, 0.4, 1.0 ]
5971 shader.setParameter(
"color", sBlue)
5972 shader.setIsTransparent(
False)
5974 shader = shaderMgr.getStockShader( self.fProxyShader )
5978 self.setLineWidth(shader, 10.0)
5981 proxyItem.setShader(shader)
5983 shaderMgr.releaseShader(shader)
5985 proxyItem = list[index]
5992 proxyItem.setCastsShadows(
not self.fExternalItems_NoShadowCast
and self.fCastsShadows )
5993 proxyItem.setReceivesShadows(
not self.fExternalItems_NoShadowReceive
and self.fReceivesShadows )
5994 proxyItem.setExcludedFromPostEffects( self.fExternalItems_NoPostEffects )
5999 haveShadedItems =
False
6003 drawMode = item.drawMode()
6004 if drawMode == omr.MGeometry.kShaded
or drawMode == omr.MGeometry.kTextured:
6005 if item.name() != self.sShadedTemplateItemName:
6006 haveShadedItems =
True
6009 displayStatus = omr.MGeometryUtilities.displayStatus(path)
6010 wireColor = omr.MGeometryUtilities.wireframeColor(path)
6017 shader = proxyItem.getShader()
6019 if displayStatus == omr.MGeometryUtilities.kTemplate:
6020 self.setSolidColor( shader, wireColor, templateColor )
6022 elif displayStatus == omr.MGeometryUtilities.kActiveTemplate:
6023 self.setSolidColor( shader, wireColor, activeTemplateColor )
6025 elif displayStatus == omr.MGeometryUtilities.kDormant:
6026 self.setSolidColor( shader, wireColor, dormantColor )
6033 if path.isTemplated():
6034 proxyItem.enable(
False)
6036 proxyItem.enable(
not haveShadedItems)
6038 proxyItem.enable(
not haveShadedItems)
6041 def updateGeometryRequirements(self, requirements, data, activeVertexCount, totalVerts, debugPopulateGeometry):
6047 positionBuffer =
None
6048 positionDataAddress =
None
6051 vertexNumericIdBuffer =
None
6052 vertexNumericIdDataAddress =
None
6053 vertexNumericIdData =
None
6055 vertexNumericIdPositionBuffer =
None
6056 vertexNumericIdPositionDataAddress =
None
6057 vertexNumericIdPositionData =
None
6059 vertexNumericLocationBuffer =
None
6060 vertexNumericLocationDataAddress =
None
6061 vertexNumericLocationData =
None
6063 vertexNumericLocationPositionBuffer =
None
6064 vertexNumericLocationPositionDataAddress =
None
6065 vertexNumericLocationPositionData =
None
6067 activeVertexPositionBuffer =
None
6068 activeVertexPositionDataAddress =
None
6069 activeVertexPositionData =
None
6071 activeVertexUVBuffer =
None
6072 activeVertexUVDataAddress =
None
6073 activeVertexUVData =
None
6075 faceCenterPositionBuffer =
None
6076 faceCenterPositionDataAddress =
None
6077 faceCenterPositionData =
None
6080 normalDataAddress =
None
6084 cpvDataAddress =
None
6088 uvDataAddress =
None
6091 numUVs = self.fMeshGeom.uvcoords.uvcount()
6093 descList = requirements.vertexRequirements()
6094 satisfiedRequirements = [
False,] * len(descList)
6095 for i
in xrange(len(descList)):
6099 if self.fDrawSharedActiveVertices
and (desc.name == self.sActiveVertexStreamName):
6100 if desc.semantic == omr.MGeometry.kPosition:
6101 if not activeVertexPositionBuffer:
6102 activeVertexPositionBuffer = data.createVertexBuffer(desc)
6103 if activeVertexPositionBuffer:
6104 satisfiedRequirements[i] =
True
6105 if debugPopulateGeometry:
6106 print ">>> Fill in data for active vertex requirement '" + desc.name +
"'. Semantic = kPosition"
6107 activeVertexPositionDataAddress = activeVertexPositionBuffer.acquire(activeVertexCount,
True)
6108 if activeVertexPositionDataAddress:
6109 activeVertexPositionData = ((ctypes.c_float * 3)*activeVertexCount).from_address(activeVertexPositionDataAddress)
6111 elif desc.semantic == omr.MGeometry.kTexture:
6112 if not activeVertexUVBuffer:
6113 activeVertexUVBuffer = data.createVertexBuffer(desc)
6114 if activeVertexUVBuffer:
6115 satisfiedRequirements[i] =
True
6116 if debugPopulateGeometry:
6117 print ">>> Fill in data for active vertex requirement '" + desc.name +
"'. Semantic = kTexture"
6118 activeVertexUVDataAddress = activeVertexUVBuffer.acquire(activeVertexCount,
True)
6119 if activeVertexUVDataAddress:
6120 activeVertexUVData = ((ctypes.c_float * 3)*activeVertexCount).from_address(activeVertexUVDataAddress)
6127 elif self.fDrawFaceCenters
and desc.name == self.sFaceCenterStreamName:
6128 if desc.semantic == omr.MGeometry.kPosition:
6129 if not faceCenterPositionBuffer:
6130 faceCenterPositionBuffer = data.createVertexBuffer(desc)
6131 if faceCenterPositionBuffer:
6132 satisfiedRequirements[i] =
True
6133 if debugPopulateGeometry:
6134 print ">>> Fill in data for face center vertex requirement '" + desc.name +
"'. Semantic = kPosition"
6135 faceCenterPositionDataAddress = faceCenterPositionBuffer.acquire(self.fMeshGeom.faceCount,
True)
6136 if faceCenterPositionDataAddress:
6137 faceCenterPositionData = ((ctypes.c_float * 3)*self.fMeshGeom.faceCount).from_address(faceCenterPositionDataAddress)
6146 if desc.semantic == omr.MGeometry.kPosition:
6147 if desc.name == self.sVertexIdItemName:
6148 if not vertexNumericIdPositionBuffer:
6149 vertexNumericIdPositionBuffer = data.createVertexBuffer(desc)
6150 if vertexNumericIdPositionBuffer:
6151 satisfiedRequirements[i] =
True
6152 if debugPopulateGeometry:
6153 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kPosition"
6154 print "Acquire 3loat-numeric position buffer"
6155 vertexNumericIdPositionDataAddress = vertexNumericIdPositionBuffer.acquire(totalVerts,
True)
6156 if vertexNumericIdPositionDataAddress:
6157 vertexNumericIdPositionData = ((ctypes.c_float * 3)*totalVerts).from_address(vertexNumericIdPositionDataAddress)
6159 elif desc.name == self.sVertexPositionItemName:
6160 if not vertexNumericLocationPositionBuffer:
6161 vertexNumericLocationPositionBuffer = data.createVertexBuffer(desc)
6162 if vertexNumericLocationPositionBuffer:
6163 satisfiedRequirements[i] =
True
6164 if debugPopulateGeometry:
6165 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kPosition"
6166 print "Acquire 3loat-numeric position buffer"
6167 vertexNumericLocationPositionDataAddress = vertexNumericLocationPositionBuffer.acquire(totalVerts,
True)
6168 if vertexNumericLocationPositionDataAddress:
6169 vertexNumericLocationPositionData = ((ctypes.c_float * 3)*totalVerts).from_address(vertexNumericLocationPositionDataAddress)
6172 if not positionBuffer:
6173 positionBuffer = data.createVertexBuffer(desc)
6175 satisfiedRequirements[i] =
True
6176 if debugPopulateGeometry:
6177 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kPosition"
6178 print "Acquire unnamed position buffer"
6179 positionDataAddress = positionBuffer.acquire(totalVerts,
True)
6180 if positionDataAddress:
6181 positionData = ((ctypes.c_float * 3)*totalVerts).from_address(positionDataAddress)
6183 elif desc.semantic == omr.MGeometry.kNormal:
6184 if not normalBuffer:
6185 normalBuffer = data.createVertexBuffer(desc)
6187 satisfiedRequirements[i] =
True
6188 if debugPopulateGeometry:
6189 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kNormal"
6190 normalDataAddress = normalBuffer.acquire(totalVerts,
True)
6191 if normalDataAddress:
6192 normalData = ((ctypes.c_float * 3)*totalVerts).from_address(normalDataAddress)
6194 elif desc.semantic == omr.MGeometry.kTexture:
6195 numericValue =
"numericvalue"
6196 numeric3Value =
"numeric3value"
6199 if desc.semanticName.lower() == numericValue
and desc.name == self.sVertexIdItemName:
6200 if not vertexNumericIdBuffer:
6201 vertexNumericIdBuffer = data.createVertexBuffer(desc)
6202 if vertexNumericIdBuffer:
6203 satisfiedRequirements[i] =
True
6204 if debugPopulateGeometry:
6205 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kTexture"
6206 print "Acquire 1loat numeric buffer"
6207 vertexNumericIdDataAddress = vertexNumericIdBuffer.acquire(totalVerts,
True)
6208 if vertexNumericIdDataAddress:
6209 vertexNumericIdData = ((ctypes.c_float * 1)*totalVerts).from_address(vertexNumericIdDataAddress)
6212 elif desc.semanticName.lower() == numeric3Value
and desc.name == self.sVertexPositionItemName:
6213 if not vertexNumericLocationBuffer:
6214 vertexNumericLocationBuffer = data.createVertexBuffer(desc)
6215 if vertexNumericLocationBuffer:
6216 satisfiedRequirements[i] =
True
6217 if debugPopulateGeometry:
6218 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kTexture"
6219 print "Acquire 3loat numeric location buffer"
6220 vertexNumericLocationDataAddress = vertexNumericLocationBuffer.acquire(totalVerts,
True)
6221 if vertexNumericLocationDataAddress:
6222 vertexNumericLocationData = ((ctypes.c_float * 3)*totalVerts).from_address(vertexNumericLocationDataAddress)
6225 elif desc.name != self.sVertexIdItemName
and desc.name != self.sVertexPositionItemName:
6227 uvBuffer = data.createVertexBuffer(desc)
6229 satisfiedRequirements[i] =
True
6230 if debugPopulateGeometry:
6231 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kTexture"
6232 print "Acquire a uv buffer"
6233 uvDataAddress = uvBuffer.acquire(totalVerts,
True)
6235 uvData = ((ctypes.c_float * 2)*totalVerts).from_address(uvDataAddress)
6237 elif desc.semantic == omr.MGeometry.kColor:
6239 cpvBuffer = data.createVertexBuffer(desc)
6241 satisfiedRequirements[i] =
True
6242 if debugPopulateGeometry:
6243 print ">>> Fill in data for requirement '" + desc.name +
"'. Semantic = kColor"
6244 cpvDataAddress = cpvBuffer.acquire(totalVerts,
True)
6246 cpvData = ((ctypes.c_float * 4)*totalVerts).from_address(cpvDataAddress)
6257 for i
in xrange(self.fMeshGeom.faceCount):
6259 numVerts = self.fMeshGeom.face_counts[i]
6261 for v
in xrange(numVerts):
6262 if any((positionData, vertexNumericIdPositionData, vertexNumericLocationPositionData, vertexNumericLocationData)):
6263 position = self.fMeshGeom.vertices[self.fMeshGeom.face_connects[vid]]
6266 positionData[pid][0] = position[0]
6267 positionData[pid][1] = position[1]
6268 positionData[pid][2] = position[2]
6271 if vertexNumericIdPositionData:
6272 vertexNumericIdPositionData[pid][0] = position[0]+1.0
6273 vertexNumericIdPositionData[pid][1] = position[1]+1.0
6274 vertexNumericIdPositionData[pid][2] = position[2]+1.0
6277 if vertexNumericLocationPositionData:
6278 vertexNumericLocationPositionData[pid][0] = position[0]+3.0
6279 vertexNumericLocationPositionData[pid][1] = position[1]+3.0
6280 vertexNumericLocationPositionData[pid][2] = position[2]+3.0
6283 if vertexNumericLocationData:
6284 vertexNumericLocationData[pid][0] = position[0]
6285 vertexNumericLocationData[pid][1] = position[1]
6286 vertexNumericLocationData[pid][2] = position[2]
6291 normal = self.fMeshGeom.normals[self.fMeshGeom.face_connects[vid]]
6292 normalData[nid][0] = normal[0]
6293 normalData[nid][1] = normal[1]
6294 normalData[nid][2] = normal[2]
6301 uvNum = self.fMeshGeom.uvcoords.uvId(vid)
6302 uv = self.fMeshGeom.uvcoords.getUV(uvNum)
6303 uvData[uvid][0] = uv[0]
6304 uvData[uvid][1] = uv[0]
6311 position = self.fMeshGeom.vertices[self.fMeshGeom.face_connects[vid]]
6312 cpvData[cid][0] = position[0]
6313 cpvData[cid][1] = position[1]
6314 cpvData[cid][2] = position[2]
6315 cpvData[cid][3] = 1.0
6320 if vertexNumericIdData:
6321 vertexNumericIdData[vid] = fMeshGeom.face_connects[vid]
6329 if positionDataAddress:
6330 positionBuffer.commit(positionDataAddress)
6332 if normalDataAddress:
6333 normalBuffer.commit(normalDataAddress)
6336 uvBuffer.commit(uvDataAddress)
6339 cpvBuffer.commit(cpvDataAddress)
6341 if vertexNumericIdDataAddress:
6342 vertexNumericIdBuffer.commit(vertexNumericIdDataAddress)
6344 if vertexNumericIdPositionDataAddress:
6345 vertexNumericIdPositionBuffer.commit(vertexNumericIdPositionDataAddress)
6347 if vertexNumericLocationDataAddress:
6348 vertexNumericLocationBuffer.commit(vertexNumericLocationDataAddress)
6350 if vertexNumericLocationPositionDataAddress:
6351 vertexNumericLocationPositionBuffer.commit(vertexNumericLocationPositionDataAddress)
6356 if activeVertexPositionData:
6357 if debugPopulateGeometry:
6358 print ">>> Fill in the data for active vertex position buffer base on component list"
6362 if activeVertexCount > len(self.fMeshGeom.vertices):
6363 activeVertexCount = len(self.fMeshGeom.vertices)
6365 for i
in xrange(activeVertexCount):
6366 position = self.fMeshGeom.vertices[ self.fActiveVertices[i] ]
6367 activeVertexPositionData[i][0] = position[0]
6368 activeVertexPositionData[i][1] = position[1]
6369 activeVertexPositionData[i][2] = position[2]
6371 activeVertexPositionBuffer.commit(activeVertexPositionDataAddress)
6373 if activeVertexUVData:
6374 if debugPopulateGeometry:
6375 print ">>> Fill in the data for active vertex uv buffer base on component list"
6379 if activeVertexCount > len(self.fMeshGeom.vertices):
6380 activeVertexCount = len(self.fMeshGeom.vertices)
6382 for i
in xrange(activeVertexCount):
6383 activeVertexUVData[i] = i / activeVertexCount
6385 activeVertexUVBuffer.commit(activeVertexUVDataAddress)
6390 if faceCenterPositionData:
6391 if debugPopulateGeometry:
6392 print ">>> Fill in the data for face center position buffer"
6398 for faceId
in xrange(self.fMeshGeom.faceCount):
6404 faceCenterPosition = om.MPoint()
6407 numVerts = self.fMeshGeom.face_counts[faceId]
6409 for v
in xrange(numVerts):
6410 face_vertex_position = self.fMeshGeom.vertices[self.fMeshGeom.face_connects[vid]]
6411 x += face_vertex_position[0]
6412 y += face_vertex_position[1]
6413 z += face_vertex_position[2]
6417 faceCenterPosition = om.MPoint(x, y, z) / numVerts
6422 faceCenterPositionData[faceId][0] = faceCenterPosition[0]
6423 faceCenterPositionData[faceId][1] = faceCenterPosition[1]
6424 faceCenterPositionData[faceId][2] = faceCenterPosition[2]
6426 faceCenterPositionBuffer.commit(faceCenterPositionDataAddress)
6430 for i
in xrange(len(descList)):
6431 if satisfiedRequirements[i]:
6434 if self.fDrawSharedActiveVertices
and (desc.name == self.sActiveVertexStreamName):
6435 if desc.semantic == omr.MGeometry.kPosition:
6436 satisfiedRequirements[i] =
True
6437 self.cloneVertexBuffer(activeVertexPositionBuffer, data, desc, activeVertexCount, debugPopulateGeometry)
6438 elif desc.semantic == omr.MGeometry.kTexture:
6439 satisfiedRequirements[i] =
True
6440 self.cloneVertexBuffer(activeVertexUVBuffer, data, desc, activeVertexCount, debugPopulateGeometry)
6441 elif self.fDrawFaceCenters
and desc.name == self.sFaceCenterStreamName:
6442 if desc.semantic == omr.MGeometry.kPosition:
6443 satisfiedRequirements[i] =
True
6444 self.cloneVertexBuffer(faceCenterPositionBuffer, data, desc, self.fMeshGeom.faceCount, debugPopulateGeometry)
6446 if desc.semantic == omr.MGeometry.kPosition:
6447 if desc.name == self.sVertexIdItemName:
6448 satisfiedRequirements[i] =
True
6449 self.cloneVertexBuffer(vertexNumericIdPositionBuffer, data, desc, totalVerts, debugPopulateGeometry)
6450 elif desc.name == self.sVertexPositionItemName:
6451 satisfiedRequirements[i] =
True
6452 self.cloneVertexBuffer(vertexNumericLocationPositionBuffer, data, desc, totalVerts, debugPopulateGeometry)
6454 satisfiedRequirements[i] =
True
6455 self.cloneVertexBuffer(positionBuffer, data, desc, totalVerts, debugPopulateGeometry)
6456 elif desc.semantic == omr.MGeometry.kNormal:
6457 satisfiedRequirements[i] =
True
6458 self.cloneVertexBuffer(normalBuffer, data, desc, totalVerts, debugPopulateGeometry)
6459 elif desc.semantic == omr.MGeometry.kTexture:
6460 numericValue =
"numericvalue"
6461 numeric3Value =
"numeric3value"
6462 if desc.semanticName.lower() == numericValue
and desc.name == self.sVertexIdItemName:
6463 satisfiedRequirements[i] =
True
6464 self.cloneVertexBuffer(vertexNumericIdBuffer, data, desc, totalVerts, debugPopulateGeometry)
6465 elif desc.semanticName.lower() == numeric3Value
and desc.name == self.sVertexPositionItemName:
6466 satisfiedRequirements[i] =
True
6467 self.cloneVertexBuffer(vertexNumericLocationBuffer, data, desc, totalVerts, debugPopulateGeometry)
6468 elif desc.name != self.sVertexIdItemName
and desc.name != self.sVertexPositionItemName:
6469 satisfiedRequirements[i] =
True
6470 self.cloneVertexBuffer(uvBuffer, data, desc, totalVerts, debugPopulateGeometry)
6471 elif desc.semantic == omr.MGeometry.kColor:
6472 satisfiedRequirements[i] =
True
6473 self.cloneVertexBuffer(cpvBuffer, data, desc, totalVerts, debugPopulateGeometry)
6475 if not satisfiedRequirements[i]:
6478 destBuffer = data.createVertexBuffer(desc)
6480 satisfiedRequirements[i] =
True
6481 if debugPopulateGeometry:
6482 print ">>> Fill in dummy requirement '%s'" % (desc.name, )
6483 destBufferDataAddress = destBuffer.acquire(totalVerts,
True)
6484 if destBufferDataAddress:
6485 destBufferData = ((ctypes.c_float * desc.dimension)*totalVerts).from_address(destBufferDataAddress)
6487 for j
in xrange(totalVerts):
6488 if desc.dimension == 4:
6489 destBufferData[j] = (1.0, 0.0, 0.0, 1.0)
6490 elif desc.dimension == 3:
6491 destBufferData[j] = (1.0, 0.0, 0.0)
6493 for k
in xrange(desc.dimension):
6494 destBufferData[j][k] = 0.0
6495 destBuffer.commit(destBufferDataAddress)
6500 def cloneVertexBuffer(self, srcBuffer, data, desc, dataSize, debugPopulateGeometry):
6502 destBuffer = data.createVertexBuffer(desc)
6504 if debugPopulateGeometry:
6505 print ">>> Cloning requirement '%s'" % (desc.name, )
6506 destBufferDataAddress = destBuffer.acquire(dataSize,
True)
6507 srcBufferDataAddress = srcBuffer.map()
6508 if destBufferDataAddress
and srcBufferDataAddress:
6509 destBufferData = ((ctypes.c_float * desc.dimension)*dataSize).from_address(destBufferDataAddress)
6510 srcBufferData = ((ctypes.c_float * desc.dimension)*dataSize).from_address(srcBufferDataAddress)
6511 if destBufferData
and srcBufferData:
6512 for j
in xrange(dataSize):
6513 for k
in xrange(desc.dimension):
6514 destBufferData[j][k] = srcBufferData[j][k]
6515 destBuffer.commit(destBufferDataAddress)
6519 def updateIndexingForWireframeItems(self, wireIndexBuffer, item, data, totalVerts):
6527 if not wireIndexBuffer:
6528 wireIndexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6530 dataAddress = wireIndexBuffer.acquire(2*totalVerts,
True)
6532 data = (ctypes.c_uint * (2*totalVerts)).from_address(dataAddress)
6536 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6538 numVerts = self.fMeshGeom.face_counts[faceIdx]
6541 for v
in xrange(numVerts-1):
6557 wireIndexBuffer.commit(dataAddress)
6561 item.associateWithIndexBuffer(wireIndexBuffer)
6563 def updateIndexingForDormantVertices(self, item, data, numTriangles):
6566 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6568 dataAddress = indexBuffer.acquire(3*numTriangles,
True)
6570 data = (ctypes.c_uint*(3*numTriangles)).from_address(dataAddress)
6575 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6577 numVerts = self.fMeshGeom.face_counts[faceIdx]
6579 for v
in xrange(1, numVerts-1):
6581 data[idx+1] = base+v
6582 data[idx+2] = base+v+1
6587 indexBuffer.commit(dataAddress)
6589 item.associateWithIndexBuffer(indexBuffer)
6591 def updateIndexingForFaceCenters(self, item, data, debugPopulateGeometry):
6594 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6596 dataAddress = indexBuffer.acquire(self.fMeshGeom.faceCount,
True)
6598 data = (ctypes.c_uint * self.fMeshGeom.faceCount).from_address(dataAddress)
6599 if debugPopulateGeometry:
6600 print ">>> Set up indexing for face centers"
6602 for i
in xrange(self.fMeshGeom.faceCount):
6607 for i
in xrange(self.fMeshGeom.faceCount):
6609 numVerts = self.fMeshGeom.face_counts[i]
6614 indexBuffer.commit(dataAddress)
6616 item.associateWithIndexBuffer(indexBuffer)
6618 def updateIndexingForVertices(self, item, data, numTriangles, activeVertexCount, debugPopulateGeometry):
6621 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6633 if self.fDrawSharedActiveVertices:
6634 dataAddress = indexBuffer.acquire(activeVertexCount,
True)
6636 data = (ctypes.c_uint*activeVertexCount).from_address(dataAddress)
6637 if debugPopulateGeometry:
6638 print ">>> Set up indexing for shared vertices"
6640 for i
in xrange(activeVertexCount):
6646 if debugPopulateGeometry:
6647 print ">>> Set up indexing for unshared vertices"
6649 vertexCount = 3*numTriangles
6650 dataAddress = indexBuffer.acquire(vertexCount,
True)
6652 data = (ctypes.c_uint*vertexCount).from_address(dataAddress)
6653 for i
in xrange(vertexCount):
6654 data[i] = vertexCount+1
6656 selectionIdSet = self.fActiveVerticesSet
6663 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6665 numVerts = self.fMeshGeom.face_counts[faceIdx]
6667 for v
in xrange(1, numVerts-1):
6668 vertexId = self.fMeshGeom.face_connects[base]
6669 if vertexId
in selectionIdSet:
6671 data[idx] = lastFound
6674 vertexId = self.fMeshGeom.face_connects[base+v]
6675 if vertexId
in selectionIdSet:
6677 data[idx] = lastFound
6680 vertexId = self.fMeshGeom.face_connects[base+v+1]
6681 if vertexId
in selectionIdSet:
6682 lastFound = base+v+1
6683 data[idx] = lastFound
6688 for i
in xrange(vertexCount):
6689 if data[i] == vertexCount+1:
6693 indexBuffer.commit(dataAddress)
6695 item.associateWithIndexBuffer(indexBuffer)
6697 def updateIndexingForEdges(self, item, data, totalVerts, fromSelection):
6700 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6702 totalEdges = 2*totalVerts
6703 totalEdgesP1 = 2*totalVerts+1
6704 dataAddress = indexBuffer.acquire(totalEdges,
True)
6706 data = (ctypes.c_uint*totalEdges).from_address(dataAddress)
6707 for i
in xrange(totalEdges):
6708 data[i] = totalEdgesP1
6711 displayAll =
not fromSelection
6712 displayActives = (
not displayAll
and bool(self.fActiveEdgesSet))
6713 displayAffected = (
not displayAll
and not displayActives)
6715 selectionIdSet =
None
6717 selectionIdSet = self.fActiveEdgesSet
6718 elif displayAffected:
6719 selectionIdSet = self.fActiveVerticesSet
6725 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6727 numVerts = self.fMeshGeom.face_counts[faceIdx]
6729 for v
in xrange(numVerts):
6730 enableEdge = displayAll
6731 vindex1 = base + (v % numVerts)
6732 vindex2 = base + ((v+1) % numVerts)
6738 vertexId = self.fMeshGeom.face_connects[vindex1]
6739 if vertexId
in selectionIdSet:
6744 vertexId2 = self.fMeshGeom.face_connects[vindex2]
6745 if vertexId2
in selectionIdSet:
6749 elif displayActives:
6752 if edgeId
in selectionIdSet:
6767 for i
in xrange(totalEdges):
6768 if data[i] == totalEdgesP1:
6771 indexBuffer.commit(dataAddress)
6773 item.associateWithIndexBuffer(indexBuffer)
6775 def updateIndexingForFaces(self, item, data, numTriangles, fromSelection):
6778 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6780 numTriangleVertices = 3*numTriangles
6781 dataAddress = indexBuffer.acquire(numTriangleVertices,
True)
6783 data = (ctypes.c_uint*numTriangleVertices).from_address(dataAddress)
6784 for i
in xrange(numTriangleVertices):
6785 data[i] = numTriangleVertices+1
6788 displayAll =
not fromSelection
6789 displayActives = (
not displayAll
and bool(self.fActiveFacesSet))
6790 displayAffected = (
not displayAll
and not displayActives)
6791 isolateSelect = item.isIsolateSelectCopy();
6795 enableFaces = [0] * self.fMeshGeom.faceCount
6797 for i
in xrange(self.fMeshGeom.faceCount):
6798 enableFaces[i] =
False
6801 fnComponent = om.MFnSingleIndexedComponent( item.shadingComponent() )
6802 if(fnComponent.componentType == om.MFn.kMeshPolygonComponent):
6803 faceIds = fnComponent.getElements()
6805 for i
in xrange(len(faceIds)):
6806 enableFaces[faceIds[i]] =
True
6809 selectionIdSet =
None
6811 selectionIdSet = self.fActiveFacesSet
6812 elif displayAffected:
6813 selectionIdSet = self.fActiveVerticesSet
6818 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6820 numVerts = self.fMeshGeom.face_counts[faceIdx]
6827 for v
in xrange(1, numVerts-1):
6828 vertexId = self.fMeshGeom.face_connects[base]
6829 if vertexId
in selectionIdSet:
6834 vertexId2 = self.fMeshGeom.face_connects[base+v]
6835 if vertexId2
in selectionIdSet:
6840 vertexId3 = self.fMeshGeom.face_connects[base+v+1]
6841 if vertexId3
in selectionIdSet:
6843 lastFound = base+v+1
6845 elif displayActives:
6846 if (
not isolateSelect
or enableFaces[faceIdx]):
6849 if faceIdx
in selectionIdSet:
6852 elif (
not isolateSelect
or enableFaces[faceIdx]):
6861 for v
in xrange(1, numVerts-1):
6863 data[idx+1] = base+v
6864 data[idx+2] = base+v+1
6870 for i
in xrange(numTriangleVertices):
6871 if data[i] == numTriangleVertices+1:
6874 indexBuffer.commit(dataAddress)
6876 item.associateWithIndexBuffer(indexBuffer)
6878 def updateIndexingForShadedTriangles(self, item, data, numTriangles):
6882 indexBuffer = data.createIndexBuffer(omr.MGeometry.kUnsignedInt32)
6884 isolateSelect = item.isIsolateSelectCopy()
6888 enableFaces = [0] * self.fMeshGeom.faceCount
6890 for i
in xrange(self.fMeshGeom.faceCount):
6891 enableFaces[i] =
False
6893 fnComponent = om.MFnSingleIndexedComponent( item.shadingComponent() )
6894 if(fnComponent.componentType == om.MFn.kMeshPolygonComponent):
6895 faceIds = fnComponent.getElements()
6897 for i
in xrange(len(faceIds)):
6898 enableFaces[faceIds[i]] =
True
6900 indices = [0] * numTriangles * 3
6904 for faceIdx
in xrange(self.fMeshGeom.faceCount):
6906 numVerts = self.fMeshGeom.face_counts[faceIdx]
6908 if (
not isolateSelect
or enableFaces[faceIdx]):
6909 for v
in xrange(1, numVerts-1):
6911 indices[idx+1] = base+v
6912 indices[idx+2] = base+v+1
6916 dataAddress = indexBuffer.acquire(len(indices),
True)
6918 data = (ctypes.c_uint * len(indices)).from_address(dataAddress)
6920 for i
in range(len(indices)):
6921 data[i] = indices[i]
6923 indexBuffer.commit(dataAddress)
6925 item.associateWithIndexBuffer(indexBuffer)
6939 sUseSubSceneOverride =
False
6940 sDrawDbClassification =
"drawdb/geometry/apiMesh"
6941 if sUseSubSceneOverride:
6942 sDrawDbClassification =
"drawdb/subscene/apiMesh"
6943 sDrawRegistrantId =
"apiMeshPlugin"
6946 def initializePlugin(obj):
6947 plugin = om.MFnPlugin(obj,
"Autodesk",
"3.0",
"Any")
6949 global sUseSubSceneOverride, sDrawDbClassification, sDrawRegistrantId
6952 plugin.registerData(
"apiMeshData", apiMeshData.id, apiMeshData.creator, om.MPxData.kGeometryData)
6954 sys.stderr.write(
"Failed to register data\n")
6958 plugin.registerShape(
"apiMesh", apiMesh.id, apiMesh.creator, apiMesh.initialize, apiMeshUI.creator, sDrawDbClassification)
6960 sys.stderr.write(
"Failed to register node\n")
6964 plugin.registerNode(
"apiMeshCreator", apiMeshCreator.id, apiMeshCreator.creator, apiMeshCreator.initialize)
6966 sys.stderr.write(
"Failed to register node\n")
6970 if sUseSubSceneOverride:
6971 omr.MDrawRegistry.registerSubSceneOverrideCreator(sDrawDbClassification, sDrawRegistrantId, apiMeshSubSceneOverride.creator)
6973 omr.MDrawRegistry.registerGeometryOverrideCreator(sDrawDbClassification, sDrawRegistrantId, apiMeshGeometryOverride.creator)
6975 sys.stderr.write(
"Failed to register override\n")
6979 if sUseSubSceneOverride:
6980 omr.MDrawRegistry.registerComponentConverter(apiMeshSubSceneOverride.sVertexSelectionName, simpleComponentConverter_subsceneOverride.creatorVertexSelection)
6981 omr.MDrawRegistry.registerComponentConverter(apiMeshSubSceneOverride.sEdgeSelectionName, simpleComponentConverter_subsceneOverride.creatorEdgeSelection)
6982 omr.MDrawRegistry.registerComponentConverter(apiMeshSubSceneOverride.sFaceSelectionName, simpleComponentConverter_subsceneOverride.creatorFaceSelection)
6984 omr.MDrawRegistry.registerComponentConverter(apiMeshGeometryOverride.sVertexItemName, meshVertComponentConverter_geometryOverride.creator)
6985 omr.MDrawRegistry.registerComponentConverter(apiMeshGeometryOverride.sEdgeSelectionItemName, meshEdgeComponentConverter_geometryOverride.creator)
6986 omr.MDrawRegistry.registerComponentConverter(apiMeshGeometryOverride.sFaceSelectionItemName, meshFaceComponentConverter_geometryOverride.creator)
6988 sys.stderr.write(
"Failed to register component converters\n")
6991 def uninitializePlugin(obj):
6992 plugin = om.MFnPlugin(obj)
6994 global sUseSubSceneOverride, sDrawDbClassification, sDrawRegistrantId
6997 if sUseSubSceneOverride:
6998 omr.MDrawRegistry.deregisterComponentConverter(apiMeshSubSceneOverride.sVertexSelectionName)
6999 omr.MDrawRegistry.deregisterComponentConverter(apiMeshSubSceneOverride.sEdgeSelectionName)
7000 omr.MDrawRegistry.deregisterComponentConverter(apiMeshSubSceneOverride.sFaceSelectionName)
7003 for faceSelectionName
in sViewSelectedFaceSelectionNames:
7004 omr.MDrawRegistry.deregisterComponentConverter(faceSelectionName)
7007 omr.MDrawRegistry.deregisterComponentConverter(apiMeshGeometryOverride.sVertexItemName)
7008 omr.MDrawRegistry.deregisterComponentConverter(apiMeshGeometryOverride.sEdgeSelectionItemName)
7009 omr.MDrawRegistry.deregisterComponentConverter(apiMeshGeometryOverride.sFaceSelectionItemName)
7011 sys.stderr.write(
"Failed to deregister component converters\n")
7015 if sUseSubSceneOverride:
7016 omr.MDrawRegistry.deregisterSubSceneOverrideCreator(sDrawDbClassification, sDrawRegistrantId)
7018 omr.MDrawRegistry.deregisterGeometryOverrideCreator(sDrawDbClassification, sDrawRegistrantId)
7020 sys.stderr.write(
"Failed to deregister override\n")
7024 plugin.deregisterNode(apiMeshCreator.id)
7026 sys.stderr.write(
"Failed to deregister node\n")
7030 plugin.deregisterNode(apiMesh.id)
7032 sys.stderr.write(
"Failed to deregister node\n")
7036 plugin.deregisterData(apiMeshData.id)
7038 sys.stderr.write(
"Failed to deregister data\n")