private void comboBoxSourceNmlMonoBehaviour_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
comboBoxSourceMesh.Items.Clear();
RefreshLabelSourceWarning();
Tuple <string, string> item = (Tuple <string, string>)comboBoxSourceNmlMonoBehaviour.SelectedItem;
if (item == null || item.Item2 == null)
{
toolTip1.SetToolTip(comboBoxSourceNmlMonoBehaviour, null);
return;
}
NmlMonoBehaviour srcNmlParser = (NmlMonoBehaviour)Gui.Scripting.Variables[item.Item2];
NmlMonoBehaviourEditor srcNmlEditor = new NmlMonoBehaviourEditor(srcNmlParser);
int selectIdx = -1;
for (int i = 0; i < srcNmlEditor.GenericMonos.Count; i++)
{
Tuple <string, int> obj = new Tuple <string, int>(srcNmlEditor.GenericMonos[i].ObjectName, i);
comboBoxSourceMesh.Items.Add(obj);
if (listViewNmlMeshes.SelectedIndices.Count > 0 && obj.Item1 == listViewNmlMeshes.SelectedItems[0].Text)
{
selectIdx = i;
}
}
comboBoxSourceMesh.SelectedIndex = selectIdx < 0 && comboBoxSourceMesh.Items.Count > 0 ? 0 : selectIdx;
string tip = item.Item1 + " (" + ((NmlMonoBehaviour)Gui.Scripting.Variables[item.Item2]).file.Parser.FilePath + ")";
toolTip1.SetToolTip(comboBoxSourceNmlMonoBehaviour, tip);
}
catch (Exception ex)
{
Utility.ReportException(ex);
}
}
public void ComputeMinMaxNormals(object[] nmlMeshIds, AnimatorEditor dstAnimatorEditor, NmlMonoBehaviourEditor srcNmlEditor, int srcNmlMeshId, AnimatorEditor srcAnimatorEditor, object[] adjacentAnimatorEditorMeshIdPairs, double adjacentSquaredDistance, bool worldCoordinates)
{
foreach (double id in nmlMeshIds)
{
int dstMeshRId = dstAnimatorEditor.GetMeshRendererId(GenericMonos[(int)id].ObjectName);
SkinnedMeshRenderer dstSMesh = (SkinnedMeshRenderer)dstAnimatorEditor.Meshes[dstMeshRId];
Operations.vMesh dstVMesh = new Operations.vMesh(dstSMesh, false, false);
List <Operations.vVertex> dstVertList = dstVMesh.submeshes[0].vertexList;
for (int i = 1; i < dstVMesh.submeshes.Count; i++)
{
dstVertList.AddRange(dstVMesh.submeshes[i].vertexList);
}
Transform meshTransform = dstSMesh.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
Matrix meshTransformMatrix = Transform.WorldTransform(meshTransform);
foreach (var vert in dstVertList)
{
vert.position = Vector3.TransformCoordinate(vert.position, meshTransformMatrix);
}
int srcMeshRId = srcAnimatorEditor.GetMeshRendererId(srcNmlMeshId < 0 ? dstSMesh.m_GameObject.instance.m_Name : srcNmlEditor.GenericMonos[srcNmlMeshId].ObjectName);
SkinnedMeshRenderer srcSMesh = (SkinnedMeshRenderer)srcAnimatorEditor.Meshes[srcMeshRId];
Operations.vMesh srcVMesh = new Operations.vMesh(srcSMesh, false, false);
List <Operations.vVertex> srcVertList = srcVMesh.submeshes[0].vertexList;
for (int i = 1; i < srcVMesh.submeshes.Count; i++)
{
srcVertList.AddRange(srcVMesh.submeshes[i].vertexList);
}
meshTransform = srcSMesh.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
meshTransformMatrix = Transform.WorldTransform(meshTransform);
foreach (var vert in srcVertList)
{
vert.position = Vector3.TransformCoordinate(vert.position, meshTransformMatrix);
}
GenericMono dstGenMono = GenericMonos.Find
(
delegate(GenericMono m)
{
return(m.ObjectName == dstSMesh.m_GameObject.instance.m_Name);
}
);
if (dstGenMono == null)
{
dstGenMono = new GenericMono();
dstGenMono.ObjectName = dstSMesh.m_GameObject.instance.m_Name;
GenericMonos.Add(dstGenMono);
}
else
{
dstGenMono.NormalMin.Clear();
dstGenMono.NormalMax.Clear();
}
GenericMono srcGenMono = srcNmlMeshId < 0
? srcNmlEditor.GenericMonos.Find
(
delegate(GenericMono m)
{
return(m.ObjectName == dstSMesh.m_GameObject.instance.m_Name);
}
)
: srcNmlEditor.GenericMonos[srcNmlMeshId];
if (srcGenMono == null)
{
throw new Exception("Source GenericMono for " + dstSMesh.m_GameObject.instance.m_Name + " not found");
}
if (srcGenMono.NormalMin.Count != srcVertList.Count)
{
throw new Exception("Source GenericMono for " + dstSMesh.m_GameObject.instance.m_Name + " has " + srcGenMono.NormalMin.Count + " normals, but the source mesh has " + srcVertList.Count + " vertices.");
}
for (int i = 0; i < dstVertList.Count; i++)
{
var vert = dstVertList[i];
int vertIdx = -1;
float minDistPos = float.MaxValue;
float minDistUV = float.MaxValue;
for (int j = 0; j < srcVertList.Count; j++)
{
var srcVert = srcVertList[j];
float distSquare = (vert.position - srcVert.position).LengthSquared();
if (distSquare < minDistPos)
{
vertIdx = j;
if ((minDistPos = distSquare) == 0)
{
distSquare = (new Vector2(vert.uv[0], vert.uv[1]) - new Vector2(srcVert.uv[0], srcVert.uv[1])).LengthSquared();
if (distSquare < minDistUV)
{
if ((minDistUV = distSquare) == 0)
{
break;
}
}
}
}
else if (distSquare == minDistPos)
{
distSquare = (new Vector2(vert.uv[0], vert.uv[1]) - new Vector2(srcVert.uv[0], srcVert.uv[1])).LengthSquared();
if (distSquare < minDistUV)
{
vertIdx = j;
if ((minDistUV = distSquare) == 0)
{
break;
}
}
}
}
dstGenMono.NormalMin.Add(vert.normal + srcGenMono.NormalMin[vertIdx] - srcGenMono.NormalMax[vertIdx]);
dstGenMono.NormalMax.Add(vert.normal);
}
if (adjacentAnimatorEditorMeshIdPairs != null)
{
HashSet <int> dstVertIndices = new HashSet <int>();
Operations.vMesh[] adjVMeshes = new Operations.vMesh[adjacentAnimatorEditorMeshIdPairs.Length / 2];
for (int i = 0; i < adjacentAnimatorEditorMeshIdPairs.Length / 2; i++)
{
MeshRenderer adjMeshR = (MeshRenderer)((AnimatorEditor)adjacentAnimatorEditorMeshIdPairs[i * 2]).Meshes[(int)(double)adjacentAnimatorEditorMeshIdPairs[i * 2 + 1]];
Matrix worldTransform;
if (worldCoordinates)
{
meshTransform = adjMeshR.m_GameObject.instance.FindLinkedComponent(typeof(Transform));
worldTransform = Transform.WorldTransform(meshTransform);
}
else
{
worldTransform = Matrix.Identity;
}
Operations.vMesh adjVMesh = new Operations.vMesh(adjMeshR, false, false);
int adjVertsAdapted = 0;
foreach (var adjSubmesh in adjVMesh.submeshes)
{
foreach (var adjVert in adjSubmesh.vertexList)
{
Vector3 adjPos = worldCoordinates
? Vector3.TransformCoordinate(adjVert.position, worldTransform)
: adjVert.position;
for (int j = 0; j < dstVertList.Count; j++)
{
var dstVert = dstVertList[j];
if ((adjPos - dstVert.position).LengthSquared() < adjacentSquaredDistance)
{
if (dstVertIndices.Add(j))
{
dstGenMono.NormalMin[j] = dstGenMono.NormalMax[j] = (dstGenMono.NormalMin[j] + dstGenMono.NormalMax[j]) / 2;
}
adjVert.normal = dstGenMono.NormalMin[j];
adjVertsAdapted++;
break;
}
}
}
}
if (adjVertsAdapted > 0)
{
adjVMeshes[i] = adjVMesh;
Report.ReportLog("Adjacent MeshRenderer " + adjMeshR.m_GameObject.instance.m_Name + " has " + adjVertsAdapted + " verts smaller squared distance than " + ((float)adjacentSquaredDistance).ToFloatString());
}
}
for (int i = 0; i < adjVMeshes.Length; i++)
{
var adjVMesh = adjVMeshes[i];
if (adjVMesh != null)
{
adjVMesh.Flush();
((AnimatorEditor)adjacentAnimatorEditorMeshIdPairs[i * 2]).Changed = true;
}
}
}
}
Parser.Param = GenericMonos;
Changed = true;
}
public void ComputeMinMaxNormals(object[] nmlMeshIds, AnimatorEditor dstAnimatorEditor, NmlMonoBehaviour srcNmlParser, int srcNmlMeshId, AnimatorEditor srcAnimatorEditor, object[] adjacentAnimatorEditorMeshIdPairs, double adjacentSquaredDistance, bool worldCoordinates)
{
NmlMonoBehaviourEditor srcNmlEditor = new NmlMonoBehaviourEditor(srcNmlParser);
ComputeMinMaxNormals(nmlMeshIds, dstAnimatorEditor, srcNmlEditor, srcNmlMeshId, srcAnimatorEditor, adjacentAnimatorEditorMeshIdPairs, adjacentSquaredDistance, worldCoordinates);
}