¿Existe una herramienta para rotar bordes en Maya 2008, concretamente spinEdge? ¿Por qué no puedo encontrarlo? ¡primeros auxilios!
//////////////////////////////////////////// // ///////////////////////////////////////////
/// Inicio del script///
////////////////////////////////// ////// ///////////////////////////////////////////// ////
// ========================
//Error
// === =====================
//
//Porque hay errores se pueden llamar en varios lugares del código, por lo que se ordenan
//de arriba a abajo para garantizar que todos los errores de tipos similares se muestren de la misma manera.
//Este error ocurre si el usuario selecciona el número o tipo de parámetros incorrecto
Error de procedimiento Error de selección ()
{
Error "Para usar spinEdge, debes seleccionar exactamente 2 caras o 1 arista";
}
//Seleccionó una arista que no tiene exactamente dos caras
procedural_edge_error()
{
Error "El borde seleccionado debe tener exactamente dos caras (puede ser un borde no múltiple o límite)";
}
//Las caras no son adyacentes o lo son en múltiples bordes
Error de ajuste del proceso ()
{
Error "Para usar spinEdge, las caras deben tener exactamente un borde adyacente";
}
//Hay una geometría no múltiple en la posición rotada
Procedimiento non_manifold_err ()
{
Error "Esta selección tiene atributos no múltiples, lo que suprime los bordes de giro";
}
// = =======================
//Utilidades
// ======== ================
//
//A menudo se llama hacer vida Funciones que se vuelven menos complejas. Algunas de estas pueden ser útiles
//Funciones de utilidad general, o se pueden mejorar de esta manera
//Esto expande la lista de caras, aristas y/o vértices para que cada elemento Tiene su propia entrada
//en la lista. Es decir, elimina la sintaxis ":" que Maya usa a menudo (molesto) para sus funciones poligonales
proc expandObjList(string $objs[], string $exp_objs[])
p>{
cadena $ exp _ objs[]= ` filtro expand-ex true-sm 34-sm 31-sm 32 $ objs `;
}
//Dada una selección, devuelve el índice de la selección. Es decir, "obj.vtx[243]" devuelve
// 243 como una cadena.
Cadena de procedimiento convert2Index(string $Obj)
{
cadena $Index[];
tokenize($Obj," [ ]",$Index);
return $Index[1];
}
//Dado un borde y un vértice, determina el vértice ¿Es en el punto inicial (0) o
//La longitud del lado final (a lo largo de 100) y devuelve el valor (0 o 1)
//
//Tenga en cuenta que se supone que el vértice está realmente en ese borde. De lo contrario, el comportamiento
// debe considerarse indefinido.
proc float distancia del borde(cadena $edge, cadena $vtx)
{
cadena $vt xid = convertir 2 índice($vtx);
p>
cadena $edge info[]= ` poli info-ev $edge `;
cadena $eVtxIDs[];
tokenize($EdgeInfo [0]," ", $eVtxIDs);
si ($vtxID == $eVtxIDs[2]) devuelve 0;
de lo contrario, devuelve 1;
}
//Dada una selección, devuelve el tipo de selección. Es decir, " obj.vtx[243]" devuelve
// "vtx "
Cadena de procedimiento getType(String $whatisthis)
{
String $esto es[];
tokenize($qué es esto,".[",$esto es);
return $esto es[1]; p>
}
//Encuentra la primera aparición del elemento en la matriz y devuelve su índice.
proc int findFirstIn(string $item, string $array[])
{
int $I = 0;
para ($I = 0; $i lt tamaño($array); $i)
{
si ($array[$i] == $artículo)
Devolver $I;
}
return-1;
}
//Devuelve un conjunto de caras compartidas entre Una lista (no filtrada) de aristas.
//Elimina los bordes del borde compartidos por una sola cara. Debería haber una manera más fácil
//Esta, pero aún no la he encontrado. ¿Quizás usar un kit?
proc string[]getshareds(string $faces[])
{
//Obtener bordes internos para prepararse para encontrar bordes compartidos. Los bordes compartidos incluyen el borde. bordes
//También obtienes los bordes del borde
string $ internal bordes[];
expandObjList(` polylistcomponentconversion-te-in $ faces ', $ internal bordes);
//Los bordes internos pueden incluir bordes como límites.
Estos deben ser ignorados
string $sharedges[];
int $sharedgecount = 0;
int $I = 0;
for($I = 0; $i lt size (tamaño interno); $i)
{
cadena $caras de borde[];
expandObjList ( `polylistcomponentconversion-TF $bordes internos[$I]`,$caras de borde);
if (tamaño $caras de borde)! = 1)
{
$ ges compartidos[$ gecount compartido]= $ bordes internos[$ I];
$ gecount compartido;
}
}
Devolver $sharedEdges
}
// ============= ============
//Comprobación de rutina
// ================== = ======
//
//Estas rutinas realizan comprobaciones básicas de la selección para verificar que es válida
//Comprueba la selección Para una cara determinada, verifique que haya dos caras y que ambas sean caras
proc check faces(string $ Selection[])
{
/ /Si tenemos caras, debemos asegurarnos de que haya dos caras y que sean adyacentes
if (size($Selection)!= 2)
{
bad _ sel _ err();
}
//Verifica que otra selección también sea válida
$ Tipo de selección = getType($ Selección[ 1]) ;
if ($SelectionType!= "f ")
{
bad _ sel _ err();
}
}
//Comprueba si un borde está seleccionado y no es un borde límite o un borde no múltiple
proc checkEdge(string $ Selección[])
{
//Verifica que solo esté seleccionado 1 borde
if (tamaño($Selección)!= 1)
{
bad _ sel _ err();
}
//Comprueba si hay dos caras.
De lo contrario, geometría no múltiple
string $Faces[];
expandObjList(` polylistcomponentconversion-TF $Selection[0]`, $Faces);
if (tamaño($Caras) == 1)
{
border _ borde _ err()
}
if ( size($Caras)!= 2)
{
non _ manifold _ err()
}
}< / p>
// ========================
//Proceso principal
/ / ========================
Proceso global OMT para girar el borde()
{
//Los principales valores a determinar, el borde de rotación y la cara que lo rodea
//Se pueden seleccionar ambos.
string $ SpinEdge
string $ spin faces[2];
//Determinar si hemos seleccionado una cara o arista, y buscar otra cara o arista
cadena $Selección[]= ` ls-sl-fl `;
cadena $Tipo de selección = getType($Selección[0]);
if ($SelectionType == "f ")
{
comprobar caras($ Selection);
//Obtener bordes compartidos
string $shared ges[]= getshared ges($Selection);
//Pruebe para asegurarse de que solo haya un borde compartido.
if(size($ ges compartidos)!= 1)
{
adj _ err();
}
//Verifica que el borde compartido tenga exactamente dos caras conectadas
string $ Faces[];
expandObjList(` polylistcomponentconversion-TF $ share ges[0]` , $ Caras);
if (size($Caras)!= 2)
{
non _ manifold _ err();
}
$ borde de giro = $ ges compartidos[0];
$ SpinFaces = $ Selección
}
Otro
{
//De lo contrario, es de esperar que podamos ver una ventaja.
if($SelectionType == "e ")
{
checkEdge($ Selección);
$ borde de giro = $ Selection[0];
expandObjList(`polylistcomponentconversion-TF $Selection[0]`,$ spin faces);
//Asegúrate de que estas caras solo compartan un borde
string $shared ges[]= getshared ges($ spin faces);
//Si hay demasiados bordes compartidos, tenemos un problema.
if(tamaño($ ges compartidos)!= 1)
{
adj _ err();
}
}
Otro
{
bad _ sel _ err()
}
}
//Tenemos nuestras propias caras y ventajas. Obtenga otros elementos de datos clave
string $EdgeVtxs[];
expandObjList(`polylistcomponentconversion-TV $spin edge', $EdgeVtxs);
string $ FaceVtxs[];
expandObjList(` polylistcomponentconversion-TV $ spin faces ', $ FaceVtxs
string $Object[]; , " ", $Objeto);
//Eliminar el borde girado. Lo recrearemos entre dos nuevos vértices
polyDelEdge $ SpinEdge
//Obtener el resultado big face
string $ big face[]= `polylistcomponentconversion-TF -in $ facevtxs `;
//Obtener los vértices de la cara en orden
string $ OrderedFaceVtxs[];
string $ FaceInfo[]= ` poli info -Fv $big face `;
tokenize($FaceInfo[0], " ", $OrderedFaceVtxs
/// Obtiene el número de vértices que tenemos. Tenga en cuenta que hay algo de basura (de polyInfo) en OrderedFaceVtxs
.
int $ bfVtxCount = size($ OrderedFaceVtxs)-3
//Encuentra el índice del nuevo vértice del borde en el vértice ordenado
//Obtener el índice Vertex actual
int $spinvtx 0 index = findFirstIn(convert 2 index($EdgeVtxs[0]), $OrderedFaceVtxs);
int $spin vtx 1 index = findFirstIn( convert 2 index($EdgeVtxs[1]),$OrderedFaceVtxs);
//Obtener el siguiente índice de vértice
int $evt x0 index =($ spin vtx 0 index-1 ) $ bfVtxCount 2;
int $evtx 1 index =($ spin vtx 1 index-1) $bfVtxCount 2;
//Obtener el siguiente vértice en sí
cadena $eVtx0 = $Objeto[0] ".vtx[" $ OrderedFaceVtxs[$ evt x0 index] "]";
cadena $eVtx1 = $Objeto[0] ".vtx[" $ OrderedFaceVtxs[ $ evtx 1 index] "]";
//Obtener el borde que queremos rotar
string $ EdgeA[]= ` polylistcomponentconversion-Fv-te-in $ EdgeVtxs [0] $evtx 0 `;
string $EdgeB[]= `polylistcomponentconversion-Fv-te-in $EdgeVtxs[1]$evtx 1 `;
//Asegúrate nuestros vértices están en el punto inicial o final del borde seleccionado
float $EdgeADist = distancia del borde($EdgeA[0], $evtx 0);
float $EdgeBDist = distancia del borde($EdgeB[ 0], $evtx 1);
//Los puntos poligonales se indexan, no los bordes (inconsistente con otras herramientas poligonales)
int $EdgeAIndex = ` convert 2 índice $ EdgeA[0]`;
int $EdgeBIndex = ` convertir 2 índice $EdgeB[0]`;
poly split-EP $EdgeAIndex $EdgeADist-EP $EdgeBIndex $EdgeBDist$ Object[0];
//Vuelva a seleccionar nuestro proyecto de "inicio".
if($SelectionType == "f ")
{
Seleccione "polylistcomponentconversion-TF-in $ facevtxs";
}
Otro
{
Seleccione "polylistcomponentconversion-te-in $ evtx 0 $ evtx 1 "
}
}