| public HasArrays ( MeshArrays channels ) : bool | ||
| channels | MeshArrays | A flag containing the array types that a ProBuilder mesh stores. |
| 리턴 | bool | |
/// <summary>
/// Collects coincident vertices and returns a rotation calculated from the average normal and bitangent.
/// </summary>
/// <param name="mesh">The target mesh.</param>
/// <param name="indices">Vertex indices to consider in the rotation calculations.</param>
/// <returns>A rotation calculated from the average normal of each vertex.</returns>
public static Quaternion GetRotation(ProBuilderMesh mesh, IEnumerable <int> indices)
{
if (!mesh.HasArrays(MeshArrays.Normal))
{
Normals.CalculateNormals(mesh);
}
if (!mesh.HasArrays(MeshArrays.Tangent))
{
Normals.CalculateTangents(mesh);
}
var normals = mesh.normalsInternal;
var tangents = mesh.tangentsInternal;
var nrm = Vector3.zero;
var tan = Vector4.zero;
float count = 0;
foreach (var index in indices)
{
var n = normals[index];
var t = tangents[index];
nrm.x += n.x;
nrm.y += n.y;
nrm.z += n.z;
tan.x += t.x;
tan.y += t.y;
tan.z += t.z;
tan.w += t.w;
count++;
}
nrm.x /= count;
nrm.y /= count;
nrm.z /= count;
tan.x /= count;
tan.y /= count;
tan.z /= count;
tan.w /= count;
if (nrm == Vector3.zero || tan == Vector4.zero)
{
return(mesh.transform.rotation);
}
var bit = Vector3.Cross(nrm, tan * tan.w);
return(mesh.transform.rotation * Quaternion.LookRotation(nrm, bit));
}
/// <summary>
/// Compile a UnityEngine.Mesh from a ProBuilderMesh.
/// </summary>
/// <param name="probuilderMesh">The mesh source.</param>
/// <param name="targetMesh">Destination UnityEngine.Mesh.</param>
/// <param name="preferredTopology">If specified, the function will try to create topology matching the reqested format (and falling back on triangles where necessary).</param>
/// <returns>The resulting material array from the compiled faces array. This is suitable to assign to the MeshRenderer.sharedMaterials property.</returns>
public static void Compile(ProBuilderMesh probuilderMesh, Mesh targetMesh, MeshTopology preferredTopology = MeshTopology.Triangles)
{
if (probuilderMesh == null)
{
throw new ArgumentNullException("probuilderMesh");
}
if (targetMesh == null)
{
throw new ArgumentNullException("targetMesh");
}
targetMesh.Clear();
targetMesh.vertices = probuilderMesh.positionsInternal;
targetMesh.uv = probuilderMesh.texturesInternal;
if (probuilderMesh.HasArrays(MeshArrays.Texture2))
{
List <Vector4> uvChannel = new List <Vector4>();
probuilderMesh.GetUVs(2, uvChannel);
targetMesh.SetUVs(2, uvChannel);
}
if (probuilderMesh.HasArrays(MeshArrays.Texture3))
{
List <Vector4> uvChannel = new List <Vector4>();
probuilderMesh.GetUVs(3, uvChannel);
targetMesh.SetUVs(3, uvChannel);
}
targetMesh.normals = probuilderMesh.GetNormals();
targetMesh.tangents = probuilderMesh.GetTangents();
if (probuilderMesh.HasArrays(MeshArrays.Color))
{
targetMesh.colors = probuilderMesh.colorsInternal;
}
var materialCount = probuilderMesh.GetComponent <Renderer>().sharedMaterials.Length;
var submeshes = Submesh.GetSubmeshes(probuilderMesh.facesInternal, materialCount, preferredTopology);
targetMesh.subMeshCount = submeshes.Length;
for (int i = 0; i < targetMesh.subMeshCount; i++)
{
targetMesh.SetIndices(submeshes[i].m_Indexes, submeshes[i].m_Topology, i, false);
}
targetMesh.name = string.Format("pb_Mesh{0}", probuilderMesh.id);
}
/// <summary>
/// Calculate mesh normals without taking into account smoothing groups.
/// </summary>
/// <returns>A new array of the vertex normals.</returns>
/// <seealso cref="CalculateNormals"/>
static void CalculateHardNormals(ProBuilderMesh mesh)
{
var vertexCount = mesh.vertexCount;
var positions = mesh.positionsInternal;
var faces = mesh.facesInternal;
// s_CachedIntArray acts as the average count per-normal
ClearIntArray(vertexCount);
if (!mesh.HasArrays(MeshArrays.Normal))
{
mesh.normalsInternal = new Vector3[vertexCount];
}
var normals = mesh.normalsInternal;
for (int i = 0; i < vertexCount; i++)
{
normals[i].x = 0f;
normals[i].y = 0f;
normals[i].z = 0f;
}
for (int faceIndex = 0, fc = faces.Length; faceIndex < fc; faceIndex++)
{
int[] indexes = faces[faceIndex].indexesInternal;
for (var tri = 0; tri < indexes.Length; tri += 3)
{
int a = indexes[tri], b = indexes[tri + 1], c = indexes[tri + 2];
Vector3 cross = Math.Normal(positions[a], positions[b], positions[c]);
cross.Normalize();
normals[a].x += cross.x;
normals[b].x += cross.x;
normals[c].x += cross.x;
normals[a].y += cross.y;
normals[b].y += cross.y;
normals[c].y += cross.y;
normals[a].z += cross.z;
normals[b].z += cross.z;
normals[c].z += cross.z;
s_CachedIntArray[a]++;
s_CachedIntArray[b]++;
s_CachedIntArray[c]++;
}
}
for (var i = 0; i < vertexCount; i++)
{
normals[i].x = normals[i].x / s_CachedIntArray[i];
normals[i].y = normals[i].y / s_CachedIntArray[i];
normals[i].z = normals[i].z / s_CachedIntArray[i];
}
}
public static void CalculateTangents(ProBuilderMesh mesh)
{
int vc = mesh.vertexCount;
if (!mesh.HasArrays(MeshArrays.Tangent))
{
mesh.tangentsInternal = new Vector4[vc];
}
if (!mesh.HasArrays(MeshArrays.Position) || !mesh.HasArrays(MeshArrays.Texture0))
{
return;
}
// http://answers.unity3d.com/questions/7789/calculating-tangents-vector4.html
Vector3[] normals = mesh.GetNormals();
var positions = mesh.positionsInternal;
var textures = mesh.texturesInternal;
var tan1 = new Vector3[vc];
var tan2 = new Vector3[vc];
var tangents = mesh.tangentsInternal;
foreach (var face in mesh.facesInternal)
{
int[] triangles = face.indexesInternal;
for (int a = 0, c = triangles.Length; a < c; a += 3)
{
long i1 = triangles[a + 0];
long i2 = triangles[a + 1];
long i3 = triangles[a + 2];
Vector3 v1 = positions[i1];
Vector3 v2 = positions[i2];
Vector3 v3 = positions[i3];
Vector2 w1 = textures[i1];
Vector2 w2 = textures[i2];
Vector2 w3 = textures[i3];
float x1 = v2.x - v1.x;
float x2 = v3.x - v1.x;
float y1 = v2.y - v1.y;
float y2 = v3.y - v1.y;
float z1 = v2.z - v1.z;
float z2 = v3.z - v1.z;
float s1 = w2.x - w1.x;
float s2 = w3.x - w1.x;
float t1 = w2.y - w1.y;
float t2 = w3.y - w1.y;
float r = 1.0f / (s1 * t2 - s2 * t1);
Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
tan1[i1] += sdir;
tan1[i2] += sdir;
tan1[i3] += sdir;
tan2[i1] += tdir;
tan2[i2] += tdir;
tan2[i3] += tdir;
}
}
for (long a = 0; a < vc; ++a)
{
Vector3 n = normals[a];
Vector3 t = tan1[a];
Vector3.OrthoNormalize(ref n, ref t);
tangents[a].x = t.x;
tangents[a].y = t.y;
tangents[a].z = t.z;
tangents[a].w = (Vector3.Dot(Vector3.Cross(n, t), tan2[a]) < 0.0f) ? -1.0f : 1.0f;
}
}
