internal void ChangeMeshRender(MeshState type)
{
if (m_MeshData != null)
{
m_MeshData.ChangeMeshRender(type);
}
}
protected override void OnAwake()
{
m_multiThreading = 1 < SystemInfo.processorCount;
if (m_multiThreading)
{
ThreadPool.InitInstance();
}
base.OnAwake();
m_selfTransform = transform;
m_meshState = MeshState.Uncreated;
if (m_meshTree != null)
{
if (!m_meshTree.IsBuildFinished())
{
if (m_meshTree.IsPrebuilt())
{
m_meshTree.BuildFromPrebuiltData();
if (Debug.isDebugBuild || Application.isEditor)
{
CheckError();
}
}
else
{
m_meshTree.AsyncBuild();
}
}
m_search = m_meshTree.CreateSearch();
}
}
/// <summary>Apply a set of weights to create the corresponding deformation</summary>
/// <param name="meshState">Instance of MeshState that provides the weight set</param>
/// <exception cref="System.ArgumentException">Thrown when the set length is not compatible with the length of the set of blend shapes</exception>
public virtual void ApplyMeshState(MeshState meshState)
{
for (int i = 0; i < blendShapesCount; i++)
{
ApplyWeight(i, meshState.GetWeight(i));
}
}
public void SyncAndSwap()
{
#if UNITY_EDITOR
if (m_search == null)
{
return;
}
#endif
if (m_meshState == MeshState.Creating)
{
m_search.Wait();
if (m_search.bounds.extents == Vector3.zero)
{
Hide(true);
}
else
{
Hide(false);
SwapMesh();
currentMesh.Clear();
currentMesh.vertices = m_search.vertices;
if (m_search.m_bOutputNormals)
{
currentMesh.normals = m_search.normals;
}
currentMesh.triangles = m_search.triangles;
currentMesh.bounds = m_search.bounds;
}
m_meshState = MeshState.Created;
}
}
private void RemoveMesh()
{
if (currentMeshState == MeshState.LOADED)
{
pcManager.GetMeshManager().ReleaseMesh(meshFilter.mesh); //Returning Mesh
meshFilter.mesh = null;
currentMeshState = MeshState.NOT_LOADED;
}
}
void Awake()
{
meshState = MeshState.HasOldData;
mainTextureId = Shader.PropertyToID("_MainTex");
meshRenderer = transform.GetChild(0).GetComponent <MeshRenderer>();
meshFilter = transform.GetChild(0).GetComponent <MeshFilter>();
if (!shader)
{
shader = Shader.Find("Unlit/Transparent Cutout");
}
}
private void SetMeshState(MeshState newState)
{
// If the mesh state has not changed, return
if (currentMeshState == newState)
{
return;
}
// Otherwise, make changes to the UI based on the new state
switch (newState)
{
// If the mesh is in the no file state, show the mesh status message and disable the mesh
// renderer
case MeshState.NoFile:
if (!MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(true);
}
if (meshRenderer.enabled)
{
meshRenderer.enabled = false;
}
break;
// If the mesh is in the initialising state, show the mesh status message and disable the mesh
// renderer again, but also trigger the method to initialise the mesh
case MeshState.InitialisingMesh:
if (!MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(true);
}
if (meshRenderer.enabled)
{
meshRenderer.enabled = false;
}
break;
// For the rendering mesh state, hide the mesh status message if visible, then enable the
// mesh renderer if not visible
case MeshState.RenderingMesh:
if (MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(false);
}
if (!meshRenderer.enabled)
{
meshRenderer.enabled = true;
}
break;
}
// Store the new state
currentMeshState = newState;
}
/// <summary>Apply a set of weights to create the corresponding face expression</summary>
/// <param name="preset">Array containing all the weights needed</param>
/// <exception cref="System.ArgumentException">Thrown when the set length is not compatible with the length of the set of blend shapes.</exception>
public override void ApplyMeshState(MeshState meshState)
{
// Base function is overriden to be able to manage eyes movements independently
for (int i = 0; i < GetBlendShapesCount(); i++)
{
if (stateIncludeEyes || !ManuelBastioniBlendShapes.BelongsToZone(ManuelBastioniBlendShapes.Zone.Eyes, i)) // (stateIncludeEyes OR (!stateIncludeEyes AND !BelongsToZone(Eyes, i)))
{
ApplyWeight(i, meshState.GetWeight(i));
}
}
}
public void SetComponent(T meshId, MeshState subMeshState)
{
if (subMeshStates.ContainsKey(meshId))
{
subMeshStates[meshId] = subMeshState;
}
else
{
subMeshStates.Add(meshId, subMeshState);
}
}
internal void ChangeMeshRender(MeshState type)
{
if (skinnedMeshData != null)
{
skinnedMeshData.ChangeMeshRender(type);
}
if (meshRenderData != null)
{
meshRenderData.ChangeMeshRender(type);
}
}
void FetchMesh()
{
float dist = boundingSphere.DistanceTo(Camera.main.transform.position);
float priority = Camera.main.farClipPlane - dist;
Mesh mesh = pointCloudManager.GetMeshManager().CreateMesh(fileInfo, pointCloudManager, priority);
if (mesh != null)
{
meshFilter.mesh = mesh;
currentMeshState = MeshState.LOADED;
}
}
private void SetMeshState(MeshState newState)
{
// If the mesh state has not changed, return
if (currentMeshState == newState)
{
return;
}
// Otherwise, make changes to the UI based on the new state
switch (newState)
{
// For the no sensor state, show the placeholder plane, then set the mesh status text and
// display it if not already visible
case MeshState.NoSensor:
meshStatusText.text = NoSensorText;
meshStatusText.color = Color.red;
if (!MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(true);
}
break;
// For the initialising mesh and awaiting data states, show the placeholder plane again, then
// set the mesh status message text back to its default and display its container if not already
// visible
case MeshState.InitialisingMesh:
case MeshState.AwaitingData:
meshStatusText.text = meshStatusDefaultText;
if (!MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(true);
}
break;
// For the rendering mesh state, hide the mesh status message if visible,
// then enable the mesh renderer if not visible
case MeshState.RenderingMesh:
if (MeshStatusTextContainer.activeSelf)
{
MeshStatusTextContainer.SetActive(false);
}
if (!meshRenderer.enabled)
{
meshRenderer.enabled = true;
}
break;
}
// Store the new state
currentMeshState = newState;
}
public void process()
{
if (isStateSet(MeshState.Sort))
{
sort();
}
if (isStateSet(MeshState.Setup))
{
setupMesh();
}
m_State = MeshState.Null;
}
/* Begin processing vision data in a worker thread
*/
public void updateVision(int[] newDepthValues)
{
if (meshState == MeshState.HasOldData) // Only accept a new frame if the last one is finished processing. Note: Unity makes sure meshValJobHandle can't be null
{
meshState = MeshState.GeneratingData;
Profiler.BeginSample("Begin update vision job");
Thread thread = new Thread(() => asyncGenerateMesh(newDepthValues));
thread.Start();
Profiler.EndSample();
}
}
/// <summary>Initializes all attributes. If transitionDuration is set to 0, there won't be any animation (cursor value won't change over time)</summary>
/// <param name="origin">Origin face state</param>
/// <param name="objective">Objective face state</param>
/// <param name="initialCursor">Initial cursor value</param>
public MergeMeshState(MeshState origin, MeshState objective, float initialCursor = 0f, float transitionDuration = 1f, MergeStrategy mergeStrategy = MergeStrategy.Linear)
{
originWeights = origin.GetWeightSet();
objectiveWeights = objective.GetWeightSet();
this.transitionDuration = transitionDuration;
switch (mergeStrategy)
{
default:
case MergeStrategy.Linear:
computationMethod = ComputeLinear;
break;
}
SetCursor(initialCursor);
}
void FetchMesh()
{
if (currentMeshState == MeshState.NOT_LOADED)
{
float priority = 1.0f / minDistanceToCam;
Mesh mesh = pcManager.GetMeshManager().CreateMesh(fileInfo, pcManager, priority);
if (mesh != null)
{
meshFilter.mesh = mesh;
currentMeshState = MeshState.LOADED;
meshLoadingTimeSec = Time.time;
CheckMaterial();
}
}
}
// Update is called once per frame
void Update()
{
if (meshState == MeshState.HasNewData) // Has recieved data
{
lock (lockObject)
{
Profiler.BeginSample("Update kinect mesh renderer");
mesh.vertices = vertices;
mesh.triangles = triangles;
mesh.uv = uvs;
meshFilter.mesh = mesh;
Profiler.EndSample();
meshState = MeshState.HasOldData;
}
}
}
internal void ChangeMeshRender(MeshState type)
{
Material mat = null;
switch (type)
{
case MeshState.oldMesh:
{
mat = oldMesh;
break;
}
case MeshState.newMesh:
{
mat = newMesh;
break;
}
}
ChangeMeshRender(mat);
}
public void pushSortRequest()
{
m_State |= MeshState.Sort;
}
public void pushSetupRequest()
{
m_State |= MeshState.Setup;
}
public virtual void Reset()
{
if (meshFilter != null)
{
meshFilter.sharedMesh = null;
}
meshRenderer = GetComponent <MeshRenderer>();
if (meshRenderer != null)
{
meshRenderer.sharedMaterial = null;
}
if (mesh1 != null)
{
if (Application.isPlaying)
{
Destroy(mesh1);
}
else
{
DestroyImmediate(mesh1);
}
}
if (mesh2 != null)
{
if (Application.isPlaying)
{
Destroy(mesh2);
}
else
{
DestroyImmediate(mesh2);
}
}
meshState = new MeshState();
mesh1 = null;
mesh2 = null;
vertices = null;
colors = null;
uvs = null;
sharedMaterials = new Material[0];
submeshMaterials.Clear();
submeshes.Clear();
skeleton = null;
valid = false;
if (!skeletonDataAsset)
{
if (logErrors)
{
Debug.LogError("Missing SkeletonData asset.", this);
}
return;
}
SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(false);
if (skeletonData == null)
{
return;
}
valid = true;
meshFilter = GetComponent <MeshFilter>();
meshRenderer = GetComponent <MeshRenderer>();
mesh1 = newMesh();
mesh2 = newMesh();
vertices = new Vector3[0];
skeleton = new Skeleton(skeletonData);
if (initialSkinName != null && initialSkinName.Length > 0 && initialSkinName != "default")
{
skeleton.SetSkin(initialSkinName);
}
submeshSeparatorSlots.Clear();
for (int i = 0; i < submeshSeparators.Length; i++)
{
submeshSeparatorSlots.Add(skeleton.FindSlot(submeshSeparators[i]));
}
CollectSubmeshRenderers();
LateUpdate();
if (OnReset != null)
{
OnReset(this);
}
}
public void UpdateMesh()
{
#if UNITY_EDITOR
if (m_meshTree == null || m_search == null || m_search.GetType() != m_meshTree.GetSearchType())
{
if (!IsReady())
{
return;
}
OnAwake();
OnStart();
}
if (m_meshTree == null || m_meshTransform == null)
{
return;
}
#else
if (m_meshTree == null || m_meshTransform == null)
{
Hide(true);
return;
}
#endif
if (!m_meshTree.IsBuildFinished() || projector == null)
{
Hide(true);
return;
}
m_selfTransform.localScale = m_meshTransform.localScale;
m_selfTransform.position = m_meshTransform.position;
m_selfTransform.rotation = m_meshTransform.rotation;
if (predictEnabled)
{
SyncAndSwap();
if (!UpdateSearchCondition(true))
{
return;
}
m_meshState = MeshState.Creating;
m_search.AsyncStart(m_meshTree);
}
else if (m_multiThreading)
{
m_search.Wait();
if (!UpdateSearchCondition(false))
{
SyncAndSwap();
return;
}
currentMesh.bounds = m_meshTree.bounds;
m_meshState = MeshState.Creating;
m_search.AsyncStart(m_meshTree);
Hide(false);
}
else
{
if (!UpdateSearchCondition(false))
{
SyncAndSwap();
return;
}
m_meshTree.Search(m_search);
if (m_search.bounds.extents == Vector3.zero)
{
Hide(true);
}
else
{
Hide(false);
SwapMesh();
currentMesh.Clear();
currentMesh.vertices = m_search.vertices;
if (m_search.m_bOutputNormals)
{
currentMesh.normals = m_search.normals;
}
currentMesh.triangles = m_search.triangles;
currentMesh.bounds = m_search.bounds;
}
m_meshState = MeshState.Created;
}
}
public static GameObject[] Cut(GameObject target, Material material)
{
Vector3[] cutPoints = SetCutPoints.cutPoints.ToArray();
cutPlane = new Plane(cutPoints[0], cutPoints[1], cutPoints[2]);
targetMesh = target.GetComponent <MeshFilter>().mesh;
newVertices.Clear();
cuttedOBJs.Clear();
a_side.InitializeAll();
b_side.InitializeAll();
bool[] sides = new bool[3];
int point01, point02, point03;
int[] indices;
for (var v = 0; v < targetMesh.subMeshCount; v++)
{
// indices.Length = 36(0 ~ 35);
// indicesにはCube(対象)の三角メッシュのIndex情報が入る。
indices = targetMesh.GetIndices(v);
for (var i = 0; i < indices.Length; i += 3)
{
// 三角メッシュ(triangles)のパターン(0, 1, 2 ...)を各point01 ~ 03に入れる。(頂点情報)
point01 = indices[i];
point02 = indices[i + 1];
point03 = indices[i + 2];
// 各sides[0 ~ 2](BOOL)にCutPlaneが各頂点座標に対して表かをtrue, falseで返す。
sides[0] = cutPlane.GetSide(targetMesh.vertices[point01]);
sides[1] = cutPlane.GetSide(targetMesh.vertices[point02]);
sides[2] = cutPlane.GetSide(targetMesh.vertices[point03]);
// sides[0]とsides[1]がtrue or false、なおかつsides[0]とsides[2]がtrue or false の場合
// (各point01 ~ 03で構成されたtriangleの各Indexの座標がすべてcutPlaneの表または裏の場合)
if (sides[0] == sides[1] && sides[0] == sides[2])
{
Debug.Log("point01 = " + point01);
Debug.Log("point02 = " + point02);
Debug.Log("point03 = " + point03);
Debug.Log("sides[0] = " + sides[0]);
Debug.Log("sides[1] = " + sides[1]);
Debug.Log("sides[2] = " + sides[2]);
if (sides[0])
{
a_side.CreateTriangle(point01, point02, point03);
}
else
{
b_side.CreateTriangle(point01, point02, point03);
}
}
else
{
// Triangle Index 情報と各 Index のBOOL情報(切断面に対してその Triangle Index が表にあるか裏にあるか)
CutFace(sides, point01, point02, point03);
}
}
}
AddMeshMissing(target, newVertices.ToArray());
var a_mesh = new Mesh();
a_mesh.vertices = a_side.vertices.ToArray();
a_mesh.triangles = a_side.triangles.ToArray();
a_mesh.normals = a_side.normals.ToArray();
a_mesh.uv = a_side.uvs.ToArray();
var b_mesh = new Mesh();
b_mesh.vertices = b_side.vertices.ToArray();
b_mesh.triangles = b_side.triangles.ToArray();
b_mesh.normals = b_side.normals.ToArray();
b_mesh.uv = b_side.uvs.ToArray();
target.GetComponent <MeshFilter>().mesh = a_mesh;
Material[] materials = target.GetComponent <MeshRenderer>().sharedMaterials;
var a_object = target;
a_object.name = "A_Object";
var b_object = new GameObject("B_Object");
b_object.AddComponent <MeshFilter>();
b_object.AddComponent <MeshRenderer>();
b_object.transform.position = target.transform.position;
b_object.transform.rotation = target.transform.rotation;
b_object.GetComponent <MeshFilter>().mesh = b_mesh;
a_object.AddComponent <MeshCollider>();
a_object.GetComponent <MeshRenderer>().materials = materials;
a_object.GetComponent <MeshRenderer>().material.color = Color.white;
b_object.AddComponent <MeshCollider>();
b_object.GetComponent <MeshRenderer>().materials = materials;
b_object.GetComponent <MeshRenderer>().material.color = Color.green;
cuttedOBJs.Add(a_object);
cuttedOBJs.Add(b_object);
meshState = MeshState.Isolation;
return(new GameObject[] { a_object, b_object });
}
/// <summary>
/// 开始渲染，流程：
/// 随机分布Mesh
/// 分配显存
/// 把Mesh的Transform信息发送给显存
/// </summary>
public void StartRendering(Camera camera)
{
try
{
m_Camera = camera;
m_GlobalState = new GlobalState[1];
m_CB_GlobalState = new ComputeBuffer(1, Marshal.SizeOf(typeof(GlobalState)));
int[] disperseMeshs = new int[m_DisperseTempletes.Count];
if (m_DispersCount > 0)
{
float totalWeight = 0;
int[] unitCounts = new int[m_DisperseTempletes.Count];
for (int iTemplate = 0; iTemplate < m_DisperseTempletes.Count; iTemplate++)
{
totalWeight += m_DisperseTempletes[iTemplate].m_Weight;
unitCounts[iTemplate] = 0;
}
for (int iDisperse = 0; iDisperse < m_DispersCount; iDisperse++)
{
float randomWeight = UnityEngine.Random.Range(0, totalWeight);
int templateIndex = 0;
for (int iTemplate = 0; iTemplate < m_DisperseTempletes.Count; iTemplate++)
{
randomWeight -= m_DisperseTempletes[iTemplate].m_Weight;
if (randomWeight < 0)
{
templateIndex = iTemplate;
break;
}
}
disperseMeshs[templateIndex]++;
}
}
if (disperseMeshs != null && disperseMeshs.Length > 0)
{
m_CS_MainKernel = new int[disperseMeshs.Length];
for (int iDisperse = 0; iDisperse < disperseMeshs.Length; iDisperse++)
{
DisperseInfo disperseInfo = m_DisperseTempletes[iDisperse];
int disperseCount = disperseMeshs[iDisperse];
MeshState[] meshStates = new MeshState[disperseCount];
for (int iMesh = 0; iMesh < disperseCount; iMesh++)
{
Vector3 position = UnityEngine.Random.insideUnitSphere;
float magnitude = m_Offest;
magnitude += position.magnitude * (1 - m_Offest);
position.x *= m_ScaleX;
position.y *= m_ScaleY;
position.z *= m_ScaleZ;
Vector3 rotation = Vector3.zero;
if (disperseInfo.m_RandX)
{
rotation.x = UnityEngine.Random.Range(0f, 360f);
}
if (disperseInfo.m_RandY)
{
rotation.y = UnityEngine.Random.Range(0f, 360f);
}
if (disperseInfo.m_RandZ)
{
rotation.z = UnityEngine.Random.Range(0f, 360f);
}
position = position.normalized * magnitude * m_Radius;
meshStates[iMesh].LocalPosition = position;
meshStates[iMesh].LocalRotation = rotation;
meshStates[iMesh].LocalScale = RandomUtility.RandomScale(MinScale, MaxScale, ScaleMaxOffset);
}
ComputeBuffer m_CB_MeshState = new ComputeBuffer(disperseCount, Marshal.SizeOf(typeof(MeshState)));
m_CB_MeshState.SetData(meshStates);
m_CB_MeshStates.Add(m_CB_MeshState);
uint[] m_BufferArgs = new uint[5] {
disperseInfo.m_Mesh.GetIndexCount(0), (uint)disperseCount, 0, 0, 0
};
ComputeBuffer bufferArgs = new ComputeBuffer(1, (m_BufferArgs.Length * Marshal.SizeOf(typeof(uint)))
, ComputeBufferType.IndirectArguments);
bufferArgs.SetData(m_BufferArgs);
m_CB_BufferArgs.Add(bufferArgs);
m_CS_MainKernel[iDisperse] = disperseInfo.ComputeShader.FindKernel(CS_MAIN_KERNEL_NAME);
disperseInfo.ComputeShader.SetBuffer(m_CS_MainKernel[iDisperse], CS_GLOBAL_STATE_NAME, m_CB_GlobalState);
disperseInfo.ComputeShader.SetBuffer(m_CS_MainKernel[iDisperse], CS_MESH_STATES_NAME, m_CB_MeshState);
disperseInfo.ComputeShader.SetVector(CS_PARAM1_NAME, new Vector4(MinDisplayToCamera, MaxDisplayDistanceToCamera, 0, 0));
if (disperseInfo.m_UseMaterial == null)
{
disperseInfo.m_UseMaterial = new Material(disperseInfo.m_Material);
}
disperseInfo.m_UseMaterial.SetBuffer(CS_MESH_STATES_NAME, m_CB_MeshState);
disperseInfo.m_DisperseCount = disperseCount;
}
}
m_LimitBounds = CaculateLimitBounds();
}
catch (Exception e)
{
}
}
public void pushSortRequest()
{
m_State |= MeshState.Sort;
}
public void pushSetupRequest()
{
m_State |= MeshState.Setup;
}
private bool isStateSet(MeshState _State)
{
return((m_State & _State) == _State);
}
private bool isStateSet(MeshState _State)
{
return ((m_State & _State) == _State);
}
public virtual void Reset () {
if (meshFilter != null)
meshFilter.sharedMesh = null;
meshRenderer = GetComponent<MeshRenderer>();
if (meshRenderer != null) meshRenderer.sharedMaterial = null;
if (mesh1 != null) {
if (Application.isPlaying)
Destroy(mesh1);
else
DestroyImmediate(mesh1);
}
if (mesh2 != null) {
if (Application.isPlaying)
Destroy(mesh2);
else
DestroyImmediate(mesh2);
}
meshState = new MeshState();
mesh1 = null;
mesh2 = null;
vertices = null;
colors = null;
uvs = null;
sharedMaterials = new Material[0];
submeshMaterials.Clear();
submeshes.Clear();
skeleton = null;
valid = false;
if (!skeletonDataAsset) {
if (logErrors)
Debug.LogError("Missing SkeletonData asset.", this);
return;
}
SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(false);
if (skeletonData == null)
return;
valid = true;
meshFilter = GetComponent<MeshFilter>();
meshRenderer = GetComponent<MeshRenderer>();
mesh1 = newMesh();
mesh2 = newMesh();
vertices = new Vector3[0];
skeleton = new Skeleton(skeletonData);
if (initialSkinName != null && initialSkinName.Length > 0 && initialSkinName != "default")
skeleton.SetSkin(initialSkinName);
submeshSeparatorSlots.Clear();
for (int i = 0; i < submeshSeparators.Length; i++) {
submeshSeparatorSlots.Add(skeleton.FindSlot(submeshSeparators[i]));
}
CollectSubmeshRenderers();
LateUpdate();
if (OnReset != null)
OnReset(this);
}
public void clear()
{
m_State = MeshState.Null;
m_Objects = new Dictionary<uint,IGAFObject>();
m_SortedObjects = null;
}
private void AddSubmesh (MeshState.AddSubmeshArguments submeshArguments, ExposedList<bool> flipStates) { //submeshArguments is a struct, so it's ok.
int submeshIndex = submeshMaterials.Count;
submeshMaterials.Add(submeshArguments.material);
if (submeshes.Count <= submeshIndex)
submeshes.Add(new Submesh());
else if (immutableTriangles)
return;
Submesh currentSubmesh = submeshes.Items[submeshIndex];
int[] triangles = currentSubmesh.triangles;
int triangleCount = submeshArguments.triangleCount;
int firstVertex = submeshArguments.firstVertex;
int trianglesCapacity = triangles.Length;
if (submeshArguments.isLastSubmesh && trianglesCapacity > triangleCount) {
// Last submesh may have more triangles than required, so zero triangles to the end.
for (int i = triangleCount; i < trianglesCapacity; i++) {
triangles[i] = 0;
}
currentSubmesh.triangleCount = triangleCount;
} else if (trianglesCapacity != triangleCount) {
// Reallocate triangles when not the exact size needed.
currentSubmesh.triangles = triangles = new int[triangleCount];
currentSubmesh.triangleCount = 0;
}
if (!this.renderMeshes && !this.frontFacing) {
// Use stored triangles if possible.
if (currentSubmesh.firstVertex != firstVertex || currentSubmesh.triangleCount < triangleCount) { //|| currentSubmesh.triangleCount == 0
currentSubmesh.triangleCount = triangleCount;
currentSubmesh.firstVertex = firstVertex;
for (int i = 0; i < triangleCount; i += 6, firstVertex += 4) {
triangles[i] = firstVertex;
triangles[i + 1] = firstVertex + 2;
triangles[i + 2] = firstVertex + 1;
triangles[i + 3] = firstVertex + 2;
triangles[i + 4] = firstVertex + 3;
triangles[i + 5] = firstVertex + 1;
}
}
return;
}
// Iterate through all slots and store their triangles.
var drawOrderItems = skeleton.DrawOrder.Items; // Make sure to not modify ExposedList inside the loop below
var flipStatesItems = flipStates.Items; // Make sure to not modify ExposedList inside the loop below
int triangleIndex = 0; // Modified by loop
for (int i = submeshArguments.startSlot, n = submeshArguments.endSlot; i < n; i++) {
Attachment attachment = drawOrderItems[i].attachment;
bool flip = flipStatesItems[i];
// Add RegionAttachment triangles
if (attachment is RegionAttachment) {
if (!flip) {
triangles[triangleIndex] = firstVertex;
triangles[triangleIndex + 1] = firstVertex + 2;
triangles[triangleIndex + 2] = firstVertex + 1;
triangles[triangleIndex + 3] = firstVertex + 2;
triangles[triangleIndex + 4] = firstVertex + 3;
triangles[triangleIndex + 5] = firstVertex + 1;
} else {
triangles[triangleIndex] = firstVertex + 1;
triangles[triangleIndex + 1] = firstVertex + 2;
triangles[triangleIndex + 2] = firstVertex;
triangles[triangleIndex + 3] = firstVertex + 1;
triangles[triangleIndex + 4] = firstVertex + 3;
triangles[triangleIndex + 5] = firstVertex + 2;
}
triangleIndex += 6;
firstVertex += 4;
continue;
}
// Add (Skinned)MeshAttachment triangles
int[] attachmentTriangles;
int attachmentVertexCount;
var meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null) {
attachmentVertexCount = meshAttachment.vertices.Length >> 1; // length/2
attachmentTriangles = meshAttachment.triangles;
} else {
var skinnedMeshAttachment = attachment as SkinnedMeshAttachment;
if (skinnedMeshAttachment != null) {
attachmentVertexCount = skinnedMeshAttachment.uvs.Length >> 1; // length/2
attachmentTriangles = skinnedMeshAttachment.triangles;
} else
continue;
}
if (flip) {
for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii += 3, triangleIndex += 3) {
triangles[triangleIndex + 2] = firstVertex + attachmentTriangles[ii];
triangles[triangleIndex + 1] = firstVertex + attachmentTriangles[ii + 1];
triangles[triangleIndex] = firstVertex + attachmentTriangles[ii + 2];
}
} else {
for (int ii = 0, nn = attachmentTriangles.Length; ii < nn; ii++, triangleIndex++) {
triangles[triangleIndex] = firstVertex + attachmentTriangles[ii];
}
}
firstVertex += attachmentVertexCount;
}
}
public void asyncGenerateMesh(int[] depthValues)
{
lock (lockObject)
{
vertices = new Vector3[WIDTH * HEIGHT];
uvs = new Vector2[WIDTH * HEIGHT];
List <int> trianglesList = new List <int>();
Profiler.BeginSample("Get vertices");
for (int i = 0; i < WIDTH * HEIGHT; i++)
{
int x = i % WIDTH;
int y = i / WIDTH;
vertices[i] = depthToWorld(x, y, depthValues[i]);
uvs[i] = new Vector2(
Math.Max(Math.Min((1.07777777777777778f * x - 16.6666666f) / WIDTH, 1f), 0f),
Math.Min((0.9142857142857143f * y + 46.7142857f) / HEIGHT, 1f) //y - 0.08571428571428572f * y + 46.7142857f
);
}
Profiler.EndSample();
Profiler.BeginSample("Get uv and triangles");
List <int> meshTrianglesList = new List <int>();
int v1 = 0;
for (int x = 0; x < WIDTH - 1; x++)
{
for (int y = 0; y < HEIGHT - 1; y++)
{
int v2 = v1 + 1;
int v3 = v1 + WIDTH;
if (validPoint(v2, depthValues) && validPoint(v3, depthValues))
{
int v4 = v3 + 1;
if (validPoint(v1, depthValues))
{
trianglesList.Add(v1);
trianglesList.Add(v3);
trianglesList.Add(v2);
}
if (validPoint(v4, depthValues))
{
trianglesList.Add(v2);
trianglesList.Add(v3);
trianglesList.Add(v4);
}
}
v1++;
}
}
Profiler.EndSample();
Profiler.BeginSample("convert triangle List");
triangles = trianglesList.ToArray();
Profiler.EndSample();
meshState = MeshState.HasNewData;
}
}
public MeshStateWeightPair(MeshState meshState, float weight)
{
this.meshState = meshState;
this.weight = weight;
}
public void process()
{
if (isStateSet(MeshState.Sort))
sort();
if (isStateSet(MeshState.Setup))
setupMesh();
m_State = MeshState.Null;
}
public virtual void Initialize(bool overwrite)
{
if (valid && !overwrite)
{
return;
}
// Clear
{
if (meshFilter != null)
{
meshFilter.sharedMesh = null;
}
meshRenderer = GetComponent <MeshRenderer>();
if (meshRenderer != null)
{
meshRenderer.sharedMaterial = null;
}
meshState = new MeshState();
mesh1 = null;
mesh2 = null;
vertices = null;
colors = null;
uvs = null;
sharedMaterials = new Material[0];
submeshMaterials.Clear();
submeshes.Clear();
skeleton = null;
valid = false;
}
if (!skeletonDataAsset)
{
if (logErrors)
{
Debug.LogError("Missing SkeletonData asset.", this);
}
return;
}
SkeletonData skeletonData = skeletonDataAsset.GetSkeletonData(false);
if (skeletonData == null)
{
return;
}
valid = true;
meshFilter = GetComponent <MeshFilter>();
meshRenderer = GetComponent <MeshRenderer>();
mesh1 = Spine.Unity.SpineMesh.NewMesh();
mesh2 = Spine.Unity.SpineMesh.NewMesh();
vertices = new Vector3[0];
skeleton = new Skeleton(skeletonData);
if (initialSkinName != null && initialSkinName.Length > 0 && initialSkinName != "default")
{
skeleton.SetSkin(initialSkinName);
}
submeshSeparatorSlots.Clear();
for (int i = 0; i < submeshSeparators.Length; i++)
{
submeshSeparatorSlots.Add(skeleton.FindSlot(submeshSeparators[i]));
}
CollectSubmeshRenderers();
LateUpdate();
if (OnRebuild != null)
{
OnRebuild(this);
}
}
public void clear()
{
m_State = MeshState.Null;
m_Objects = new Dictionary <uint, IGAFObject>();
m_SortedObjects = null;
}
