public void TestDups()
{
MegaModifyObject mod = gameObject.GetComponent <MegaModifyObject>();
if (mod != null)
{
int[] counts = new int[mod.verts.Length];
for (int i = 0; i < Verts.Length; i++)
{
for (int v = 0; v < Verts[i].indices.Length; v++)
{
counts[Verts[i].indices[v]]++;
}
}
for (int i = 0; i < counts.Length; i++)
{
if (counts[i] > 1)
{
Debug.Log("Vert " + i + " used " + counts[i]);
}
}
Debug.Log("Done");
}
}
void Update()
{
// Find the stretch mod
if ( !mod )
{
mod = GetComponent<MegaStretch>();
modobj = GetComponent<MegaModifyObject>();
}
if ( mod )
{
Vector3 pos = transform.position;
float amt = py - ground;
if ( amt > 0.0f )
amt = 0.0f;
float y = py;
if ( y < ground )
y = ground;
if ( mod.amount == 0.0f && amt == 0.0f )
modobj.enabled = false;
else
modobj.enabled = true;
mod.amount = (amt / radius);
pos.y = y;
transform.position = pos;
}
}
public static Mesh DupMesh(Mesh mesh, MegaModifyObject mod)
{
Mesh clonemesh = new Mesh();
clonemesh.vertices = mod.verts; //mesh.vertices;
#if UNITY_5_0 || UNITY_5_1 || UNITY_5 || UNITY_2017 || UNITY_2018
clonemesh.uv2 = mesh.uv2;
clonemesh.uv3 = mesh.uv3;
clonemesh.uv4 = mesh.uv4;
#else
clonemesh.uv1 = mesh.uv1;
clonemesh.uv2 = mesh.uv2;
#endif
clonemesh.uv = mod.uvs; //mesh.uv;
clonemesh.normals = mesh.normals;
clonemesh.tangents = mesh.tangents;
clonemesh.colors = mesh.colors;
clonemesh.subMeshCount = mesh.subMeshCount;
for (int s = 0; s < mesh.subMeshCount; s++)
{
clonemesh.SetTriangles(mesh.GetTriangles(s), s);
}
CopyBlendShapes(mesh, clonemesh);
clonemesh.boneWeights = mesh.boneWeights;
clonemesh.bindposes = mesh.bindposes;
clonemesh.name = mesh.name + "_copy";
mod.RecalcNormals();
clonemesh.RecalculateBounds();
return(clonemesh);
}
void Reset()
{
MegaModifyObject modobj = (MegaModifyObject)gameObject.GetComponent<MegaModifyObject>();
if ( modobj != null )
modobj.ModReset(this);
}
void AddModType(GameObject go, System.Type name, bool modobj)
{
if (go)
{
if (!name.IsSubclassOf(typeof(MegaModifier)) && !name.IsSubclassOf(typeof(MegaWarp)))
{
go.AddComponent(name);
}
else
{
MeshFilter mf = go.GetComponent <MeshFilter>();
if (mf != null)
{
if (modobj)
{
if (name.IsSubclassOf(typeof(MegaModifier)))
{
MegaModifyObject mod = go.GetComponent <MegaModifyObject>();
if (mod == null)
{
mod = go.AddComponent <MegaModifyObject>();
mod.NormalMethod = NormalMethod;
}
}
}
if (name != null)
{
if (name.IsSubclassOf(typeof(MegaModifier)))
{
MegaModifier md = (MegaModifier)go.AddComponent(name);
if (md)
{
md.gizCol1 = col1;
md.gizCol2 = col2;
}
}
else
{
if (name.IsSubclassOf(typeof(MegaWarp)))
{
MegaWarp md = (MegaWarp)go.AddComponent(name);
if (md)
{
md.GizCol1 = col1;
md.GizCol2 = col2;
}
}
else
{
go.AddComponent(name);
}
}
}
}
}
}
}
public void ChangeWeights(GameObject obj)
{
MegaModifyObject modobj = (MegaModifyObject)obj.GetComponent <MegaModifyObject>();
MegaRubber mod = (MegaRubber)obj.GetComponent <MegaRubber>();
modobj.UpdateCol(0, Color.red);
mod.ResetPhysics();
}
static public GameObject DuplicateObjectForPrefab(GameObject from)
{
GameObject newobj = null;
if (from)
{
newobj = (GameObject)GameObject.Instantiate(from);
if (newobj)
{
MegaModifyObject[] mobjs = newobj.GetComponentsInChildren <MegaModifyObject>();
//MeshFilter[] mfil = newobj.GetComponentsInChildren<MeshFilter>();
for (int i = 0; i < mobjs.Length; i++)
{
Mesh m = MegaModifyObject.FindMesh(mobjs[i].gameObject);
if (m)
{
Mesh newmesh = DupMesh(m, mobjs[i]);
MegaModifyObject.SetMeshNew(mobjs[i].gameObject, newmesh);
}
}
//for ( int i = 0; i < mfil.Length; i++ )
//mfil[i].sharedMesh = DupMesh(mfil[i].sharedMesh, mobjs[i]);
//SkinnedMeshRenderer[] skin = newobj.GetComponentsInChildren<SkinnedMeshRenderer>();
//for ( int i = 0; i < skin.Length; i++ )
//skin[i].sharedMesh = DupMesh(skin[i].sharedMesh, mobjs[i]);
for (int i = 0; i < mobjs.Length; i++)
{
mobjs[i].MeshUpdated();
}
MegaModifier[] frommods = from.GetComponentsInChildren <MegaModifier>();
MegaModifier[] tomods = newobj.GetComponentsInChildren <MegaModifier>();
for (int i = 0; i < frommods.Length; i++)
{
tomods[i].PostCopy(frommods[i]);
}
MegaWrap[] wraps = newobj.GetComponentsInChildren <MegaWrap>();
for (int i = 0; i < wraps.Length; i++)
{
wraps[i].SetMesh();
}
newobj.name = from.name; // + " - Copy";
}
}
return(newobj);
}
Vector3 GetCentre()
{
MegaModifyObject modobj = (MegaModifyObject)gameObject.GetComponent<MegaModifyObject>();
if ( modobj != null && modobj.cachedMesh != null )
return modobj.cachedMesh.bounds.center;
return Vector3.zero;
}
public void ResetMesh()
{
if (mesh)
{
mesh.vertices = startverts;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
}
target = null;
bindverts = null;
}
// Use this for initialization
void Start()
{
if ( !mbubbl )
{
mbubbl = GetComponent<MegaBubble>();
}
if ( !modobj )
{
modobj = GetComponent<MegaModifyObject>();
}
}
public void ChangeAxis()
{
MegaModifyObject mod = GetComponent <MegaModifyObject>();
if (mod)
{
for (int i = 0; i < mod.verts.Length; i++)
{
offsets[i] = mod.verts[i][(int)axis] - mod.bbox.min[(int)axis];
}
}
}
private void Awake()
{
_ParentMode = gameObject.GetComponentInParent <CylinderPlaneMode>();
_BendMeshFilter.mesh = _RawPlaneMesh;
MegaModifyObject mob = _BendMeshFilter.gameObject.GetComponent <MegaModifyObject>();
mob.Reset();
MakeISM();
}
void OnCollisionEnter(Collision collision)
{
if (modobj == null)
{
modobj = GetComponent <MegaModifyObject>();
}
if (modobj)
{
modobj.Enabled = true;
}
colpoints = collision.contacts;
//doDeform = true;
}
//public void OnSceneGUI()
public override void DrawSceneGUI()
{
MegaPointCache mod = (MegaPointCache)target;
if ( mod.showmapping )
{
if ( mod.Verts != null && mod.Verts[0] != null )
{
float vsize = mod.mappingSize;
float vsize1 = vsize * 0.75f;
Matrix4x4 tm = mod.gameObject.transform.localToWorldMatrix;
Handles.matrix = tm; //Matrix4x4.identity;
Handles.color = Color.green;
if ( mo == null )
mo = mod.gameObject.GetComponent<MegaModifyObject>();
if ( mo )
{
for ( int i = 0; i < mo.verts.Length; i++ )
{
Vector3 p = mo.verts[i];
Handles.DotCap(i, p, Quaternion.identity, vsize);
}
}
if ( mod.mapEnd >= mod.Verts.Length )
mod.mapEnd = mod.Verts.Length - 1;
if ( mod.mapStart > mod.mapEnd )
mod.mapStart = mod.mapEnd;
Handles.color = Color.white; //red;
int findex = 0;
if ( uselastframe )
{
findex = mod.Verts[0].points.Length - 1;
}
for ( int i = mod.mapStart; i < mod.mapEnd; i++ )
{
Vector3 p = mod.Verts[i].points[findex];
Handles.DotCap(i, p, Quaternion.identity, vsize1);
}
Handles.matrix = Matrix4x4.identity;
}
}
}
private void InitBook()
{
//------------------------------------------------------------------------
//Awake
pBookPosition = new GameObject("Book");
pBookPosition.transform.localPosition = new Vector3(0, -1000, 0);
//创建plane
pPageTemplate = GameObject.CreatePrimitive(PrimitiveType.Plane);
pPageTemplate.transform.localPosition = new Vector3(0, -2000, 0);
pBookPage = new GameObject[nPageNumber];
pMaterials = new Material[pTexture2D.Length];
pMaterial = new Material[2];
//------------------------------------------------------------------------
//------------------------------------------------------------------------
//------------------------------------------------------------------------
for (int i = 0; i < pTexture2D.Length; i++)
{
Material mat = new Material(Shader.Find("Diffuse"));
mat.mainTexture = (Texture2D)pTexture2D[i];
pMaterials[i] = mat;
}
for (int i = 0; i < nPageNumber; i++)
{
pBookPage[i] = (GameObject)Instantiate(pPageTemplate);
pBookPage[i].name = (i + 1).ToString(); //改名
pBookPage[i].transform.parent = pBookPosition.transform;
pMeshRender = pBookPage[i].GetComponent <MeshRenderer>();
pMaterial[0] = pMaterials[2 * i];
pMaterial[1] = pMaterials[2 * i + 1];
pMeshRender.materials = pMaterial;
pBookPage[i].transform.localPosition = new Vector3(0, -i * 0.01f, 0);
pMegaModifyObjectScript = pBookPage[i].AddComponent <MegaModifyObject>();
pMegaPageFlipScript = pBookPage[i].AddComponent <MegaPageFlip>();
pMegaMeshPageScript = pBookPage[i].AddComponent <MegaMeshPage>();
pMegaMeshPageScript.Rebuild();
}
}
public int updateRate = 0; // update rate of mesh, 0 is every frame 1 every other etc
#endregion Fields
#region Methods
// Call this to set the source game object which has the working point cache modifier attached
public void SetSource(GameObject srcobj)
{
if ( srcobj )
{
if ( mesh == null )
mesh = MegaUtils.GetMesh(gameObject);
Mesh srcmesh = MegaUtils.GetMesh(srcobj);
if ( srcmesh.vertexCount == mesh.vertexCount )
{
obj = srcobj;
mod = (MegaPointCache)srcobj.GetComponent<MegaPointCache>();
modobj = (MegaModifyObject)srcobj.GetComponent<MegaModifyObject>();
mesh = MegaUtils.GetMesh(gameObject);
}
}
}
static GameObject CopyMesh(GameObject subject, MegaModifyObject mod)
{
GameObject clone = new GameObject(); //(GameObject)GameObject.Instantiate(subject);
//GameObject.DestroyImmediate(clone.GetComponent<MeshFilter>());
//GameObject.DestroyImmediate(clone.GetComponent<MeshRenderer>());
//MeshFilter oldmf = subject.GetComponent<MeshFilter>();
MeshFilter newmf = clone.AddComponent<MeshFilter>();
SkinnedMeshRenderer oldsmr = subject.GetComponent<SkinnedMeshRenderer>();
if ( oldsmr )
{
SkinnedMeshRenderer newsmr = clone.AddComponent<SkinnedMeshRenderer>();
newsmr.sharedMaterials = oldsmr.sharedMaterials;
}
else
{
MeshRenderer oldmr = subject.GetComponent<MeshRenderer>();
MeshRenderer newmr = clone.AddComponent<MeshRenderer>();
newmr.sharedMaterials = oldmr.sharedMaterials;
}
MeshFilter[] mfs = subject.GetComponentsInChildren<MeshFilter>();
//MeshFilter[] clonemfs = clone.GetComponentsInChildren<MeshFilter>();
MeshCollider[] mcs = clone.GetComponentsInChildren<MeshCollider>();
MeshCollider[] clonemcs = clone.GetComponentsInChildren<MeshCollider>();
int l = mfs.Length;
for ( int i = 0; i < l; i++ )
{
MeshFilter mf = mfs[i];
//MeshFilter clonemf = clonemfs[i];
Mesh mesh = mf.sharedMesh;
Mesh clonemesh = new Mesh();
//clonemesh.vertices = (Vector3[])mod.verts.Clone();
//mod.verts.CopyTo(clonemesh.vertices, 0);
clonemesh.vertices = mod.verts; //mesh.vertices;
clonemesh.uv1 = mesh.uv1;
clonemesh.uv2 = mesh.uv2;
clonemesh.uv = mod.uvs; //mesh.uv;
clonemesh.normals = mod.norms; //mesh.normals;
clonemesh.tangents = mesh.tangents;
clonemesh.colors = mesh.colors;
clonemesh.subMeshCount = mesh.subMeshCount;
for ( int s = 0; s < mesh.subMeshCount; s++ )
{
clonemesh.SetTriangles(mesh.GetTriangles(s), s);
}
//clonemesh.triangles = mesh.triangles;
clonemesh.boneWeights = mesh.boneWeights;
clonemesh.bindposes = mesh.bindposes;
clonemesh.name = mesh.name + "_copy";
clonemesh.RecalculateBounds();
//clonemf.sharedMesh = clonemesh;
//MeshFilter newmf = clone.AddComponent<MeshFilter>();
newmf.sharedMesh = clonemesh;
//clone.AddComponent<MeshRenderer>();
for ( int j = 0; j < mcs.Length; j++ )
{
MeshCollider mc = mcs[j];
if ( mc.sharedMesh = mesh )
clonemcs[j].sharedMesh = clonemesh;
}
}
return clone;
}
public void AttachOld(MegaModifyObject modobj)
{
if ( mesh && startverts != null )
mesh.vertices = startverts;
if ( modobj == null )
{
bindverts = null;
return;
}
nomapcount = 0;
if ( mesh )
mesh.vertices = startverts;
MeshFilter mf = GetComponent<MeshFilter>();
if ( mesh == null )
mesh = CloneMesh(mf.mesh);
mf.mesh = mesh;
//Mesh basemesh = MegaUtils.GetMesh(go);
verts = mesh.vertices;
startverts = mesh.vertices;
freeverts = new Vector3[startverts.Length];
Vector3[] baseverts = modobj.verts; //basemesh.vertices;
int[] basefaces = modobj.tris; //basemesh.triangles;
bindverts = new MegaBindVert[verts.Length];
// matrix to get vertex into local space of target
Matrix4x4 tm = transform.localToWorldMatrix * modobj.transform.worldToLocalMatrix;
for ( int i = 0; i < verts.Length; i++ )
{
//Debug.Log("i " + i + " " + verts[i]);
MegaBindVert bv = new MegaBindVert();
bindverts[i] = bv;
Vector3 p = tm.MultiplyPoint(verts[i]);
//Debug.Log("p " + p);
p = transform.TransformPoint(verts[i]);
p = modobj.transform.InverseTransformPoint(p);
freeverts[i] = p;
//Debug.Log("p " + p);
float tweight = 0.0f;
for ( int t = 0; t < basefaces.Length; t += 3 )
{
Vector3 p0 = baseverts[basefaces[t]];
Vector3 p1 = baseverts[basefaces[t + 1]];
Vector3 p2 = baseverts[basefaces[t + 2]];
//Debug.Log("Face " + p0 + " " + p1 + " " + p2);
Vector3 normal = FaceNormal(p0, p1, p2);
//float dot = Vector3.Dot(normal, p - p0);
#if true
//Debug.Log("Dot " + dot);
//if ( dot > 0.0f )
{
float dist = GetDistance(p, p0, p1, p2);
//Debug.Log("Dist " + dist);
//if ( dist >= 0.0f && dist < maxdist )
if ( Mathf.Abs(dist) < maxdist )
{
MegaBindInf bi = new MegaBindInf();
bi.dist = GetPlaneDistance(p, p0, p1, p2); //dist;
bi.face = t;
bi.i0 = basefaces[t];
bi.i1 = basefaces[t + 1];
bi.i2 = basefaces[t + 2];
bi.bary = CalcBary(p, p0, p1, p2);
//Debug.Log("Bary " + bi.bary);
bi.weight = 1.0f / (1.0f + dist);
bi.area = normal.magnitude * 0.5f; //CalcArea(baseverts[basefaces[t]], baseverts[basefaces[t + 1]], baseverts[basefaces[t + 2]]); // Could calc once at start
//Debug.Log("Weight " + bi.weight + " area " + bi.area);
tweight += bi.weight;
bv.verts.Add(bi);
if ( maxpoints > 0 && bv.verts.Count >= maxpoints )
break;
}
}
#endif
}
if ( tweight == 0.0f )
{
nomapcount++;
}
//Debug.Log("TWeight " + tweight);
bv.weight = tweight;
}
// for each vert, find faces that are close enough and thatvert is above
// find closest point on that face
// calc bary coord and find distance from plane of face
// calc area of face for weighting
// keep track of all faces in range for combined weight
}
public void ResetMesh()
{
if ( mesh && source )
{
mesh.vertices = source.startverts;
mesh.RecalculateBounds();
RecalcNormals();
//mesh.RecalculateNormals();
}
target = null;
//bindverts = null;
}
static void CopyModObj(MegaModifyObject from, MegaModifyObject to)
{
if ( from && to )
{
to.Enabled = from.Enabled;
to.recalcbounds = from.recalcbounds;
to.recalcCollider = from.recalcCollider;
to.recalcnorms = from.recalcnorms;
to.DoLateUpdate = from.DoLateUpdate;
to.GrabVerts = from.GrabVerts;
to.DrawGizmos = from.DrawGizmos;
to.NormalMethod = from.NormalMethod;
}
}
void OnCollisionEnter(Collision collision)
{
if ( modobj == null )
modobj = GetComponent<MegaModifyObject>();
if ( modobj )
modobj.Enabled = true;
colpoints = collision.contacts;
//doDeform = true;
}
public void OnSceneGUI()
{
MegaMorph mod = (MegaMorph)target;
if ( mod.showmapping )
{
if ( mod.oPoints != null )
{
float vsize = mod.mappingSize;
float vsize1 = vsize * 0.75f;
Matrix4x4 tm = mod.gameObject.transform.localToWorldMatrix;
Handles.matrix = tm; //Matrix4x4.identity;
Handles.color = Color.green;
if ( mo == null )
mo = mod.gameObject.GetComponent<MegaModifyObject>();
if ( mo )
{
for ( int i = 0; i < mo.verts.Length; i++ )
{
Vector3 p = mo.verts[i];
Handles.DotCap(i, p, Quaternion.identity, vsize);
}
}
if ( mod.mapEnd >= mod.oPoints.Length )
mod.mapEnd = mod.oPoints.Length - 1;
if ( mod.mapStart > mod.mapEnd )
mod.mapStart = mod.mapEnd;
Handles.color = Color.red;
for ( int i = mod.mapStart; i < mod.mapEnd; i++ )
{
Vector3 p = mod.oPoints[i];
Handles.DotCap(i, p, Quaternion.identity, vsize1);
}
Handles.matrix = Matrix4x4.identity;
}
}
}
void Update()
{
// Find the mods
if ( !modffd )
{
modffd = GetComponent<MegaFFD3x3x3>();
modobj = GetComponent<MegaModifyObject>();
}
if ( modffd )
{
Vector3 toolPosition = tool.transform.position;
size = modffd.GridSize();
int gridSize = size*size*size;
distance = new float[gridSize];
entries = new int[gridSize];
indicies = new Vector3[gridSize];
if(inCollision){
for ( int i = 0; i < size; i++ ) // TODO: dim for all ffd
{
for ( int j = 0; j < size; j++ )
{
for ( int k = 0; k < size; k++ )
{
int c = modffd.GridIndex(i, j, k);
indicies[c] = new Vector3 (i,j,k); //indicies of the handle i,j,k
entries[c]=c;
distance[c] = Vector3.Distance(transform.TransformPoint(modffd.GetPoint(i,j,k)),collisionPoint);//There should be collision point instead of pposition of the tool
}
}
}
System.Array.Sort(distance, entries);
if(sphereSwitch){
if(!redSphere){
redSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
redSphere.GetComponent<Renderer>().material.color = Color.red;
redSphere.transform.localScale = new Vector3(0.2f, 0.2f,0.2f);
redSphere.name = "Red Sphere";
}
if(!blueSphere){
blueSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
blueSphere.GetComponent<Renderer>().material.color = Color.blue;
blueSphere.transform.localScale = new Vector3(0.2f, 0.2f,0.2f);
blueSphere.name = "Blue Sphere";
}
if(!greenSphere){
greenSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
greenSphere.GetComponent<Renderer>().material.color = Color.green;
greenSphere.transform.localScale = new Vector3(0.2f, 0.2f,0.2f);
greenSphere.name = "Green Sphere";
}
if(!yellowSphere){
yellowSphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
yellowSphere.GetComponent<Renderer>().material.color = Color.yellow;
yellowSphere.transform.localScale = new Vector3(0.2f, 0.2f,0.2f);
yellowSphere.name = "Yellow Sphere";
}
redSphere.transform.position = modffd.GetPoint(entries[0]);
blueSphere.transform.position = modffd.GetPoint(entries[1]);
greenSphere.transform.position = modffd.GetPoint(entries[2]);
yellowSphere.transform.position = modffd.GetPoint(entries[3]);
}
else{
Destroy(redSphere);
Destroy(blueSphere);
Destroy(greenSphere);
Destroy(yellowSphere);
}
Vector4 neighbors = new Vector4(distance[0],distance[1],distance[2],distance[3]);
neighbors.Normalize();
for(int i = 0; i < 4; i++){
if(neighbors[i]==0){
neighbors[i]=0.01f;
}
neighbors[i] = 1 / neighbors[i];
}
neighbors.Normalize();
currentPosition = tool.transform.position;
displacement = currentPosition-previousPosition;
Debug.Log("Displacement: " +displacement);
if(!firsttimecollision)
{
// positionoffirstcollisionpoint += displacement;
//
// if(displacement.y < 0 && (positionoffirstcollisionpoint.y < firstcollisionpoint.y) )
// {
if(deformation){
// Debug.Log (neighbors);
//Debug.Log (displacement);
for(int i = 0; i < 4; i++){
int l = entries[i];
Vector3 index = indicies[l];
int x = (int)index.x;
int y = (int)index.y;
int z = (int)index.z;
float neighbor = neighbors[i];
finalDisplacement = -displacement*coefficient*neighbor;//new Vector3 (0,0,0.001f);//displacement*neighbor;
// Debug.Log("Neighbor: " +neighbor);
modffd.MovePoint(x,y,z,finalDisplacement);
}
float centerY = sphCollider.center.y - displacement.y*coefficientCollider;//*coefficient;
sphCollider.center = new Vector3(colliderPosition.x,centerY,colliderPosition.z);
//planeT.transform.localScale+= new Vector3(finalDisplacement.x*1000,0,0);
// float centerY;
// centerY = sphCollider.center.y - displacement.y*coefficient;
// sphCollider.center = new Vector3 (colliderPosition.x,centerY,colliderPosition.z);
// if((colliderPosition.y-centerY)<=0.001f){
// sphCollider.center=colliderPosition;
// }
}
// }
}
else
{
firsttimecollision = false;
firstcollisionpoint = collisionPoint;
positionoffirstcollisionpoint = firstcollisionpoint;
}
previousPosition=currentPosition;
// Debug.Log("distance[0]: " +distance[0] + " distance[1]: " +distance[1] + " distance[2]: " + distance[2]);
// Debug.Log("entries[0]: " +entries[0] + " entries[1]: " +entries[1] + " entries[2]: " + entries[2]);
// Debug.Log (indicies[2]);
}
}
}
// Simple physics timsetp
void Start()
{
if ( !modffd )
{
modffd = GetComponent<MegaFFD3x3x3>();
modobj = GetComponent<MegaModifyObject>();
}
if(modffd){
System.Array.Copy(modffd.pt,initialHandlesPosition,64);
//modffd.pt.CopyTo(initialHandlesPosition,64);
Debug.Log ("Initial handles position stored");
}
planeT = GameObject.Find("PlaneTunnel");
sphCollider = GetComponent<SphereCollider>();
colliderPosition = sphCollider.center;
}
public void ResetMesh()
{
if ( mesh )
{
mesh.vertices = startverts;
mesh.RecalculateBounds();
mesh.RecalculateNormals();
}
target = null;
bindverts = null;
}
public void Attach(MegaModifyObject modobj)
{
targetIsSkin = false;
sourceIsSkin = false;
if ( mesh && startverts != null )
mesh.vertices = startverts;
if ( modobj == null )
{
bindverts = null;
return;
}
nomapcount = 0;
if ( mesh )
mesh.vertices = startverts;
MeshFilter mf = GetComponent<MeshFilter>();
Mesh srcmesh = null;
if ( mf != null )
{
//skinned = false;
srcmesh = mf.mesh;
}
else
{
SkinnedMeshRenderer smesh = (SkinnedMeshRenderer)GetComponent(typeof(SkinnedMeshRenderer));
if ( smesh != null )
{
//skinned = true;
srcmesh = smesh.sharedMesh;
sourceIsSkin = true;
}
}
if ( mesh == null )
mesh = CloneMesh(srcmesh); //mf.mesh);
if ( mf )
mf.mesh = mesh;
else
{
SkinnedMeshRenderer smesh = (SkinnedMeshRenderer)GetComponent(typeof(SkinnedMeshRenderer));
smesh.sharedMesh = mesh;
}
if ( sourceIsSkin == false )
{
SkinnedMeshRenderer tmesh = (SkinnedMeshRenderer)modobj.GetComponent(typeof(SkinnedMeshRenderer));
if ( tmesh != null )
{
targetIsSkin = true;
if ( !sourceIsSkin )
{
Mesh sm = tmesh.sharedMesh;
bindposes = sm.bindposes;
boneweights = sm.boneWeights;
bones = tmesh.bones;
skinnedVerts = sm.vertices; //new Vector3[sm.vertexCount];
}
}
}
neededVerts.Clear();
verts = mesh.vertices;
startverts = mesh.vertices;
freeverts = new Vector3[startverts.Length];
Vector3[] baseverts = modobj.verts; //basemesh.vertices;
int[] basefaces = modobj.tris; //basemesh.triangles;
bindverts = new MegaBindVert[verts.Length];
// matrix to get vertex into local space of target
Matrix4x4 tm = transform.localToWorldMatrix * modobj.transform.worldToLocalMatrix;
List<MegaCloseFace> closefaces = new List<MegaCloseFace>();
Vector3 p0 = Vector3.zero;
Vector3 p1 = Vector3.zero;
Vector3 p2 = Vector3.zero;
for ( int i = 0; i < verts.Length; i++ )
{
MegaBindVert bv = new MegaBindVert();
bindverts[i] = bv;
Vector3 p = tm.MultiplyPoint(verts[i]);
p = transform.TransformPoint(verts[i]);
p = modobj.transform.InverseTransformPoint(p);
freeverts[i] = p;
closefaces.Clear();
for ( int t = 0; t < basefaces.Length; t += 3 )
{
if ( targetIsSkin && !sourceIsSkin )
{
p0 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t]));
p1 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t + 1]));
p2 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t + 2]));
}
else
{
p0 = baseverts[basefaces[t]];
p1 = baseverts[basefaces[t + 1]];
p2 = baseverts[basefaces[t + 2]];
}
float dist = GetDistance(p, p0, p1, p2);
if ( Mathf.Abs(dist) < maxdist )
{
MegaCloseFace cf = new MegaCloseFace();
cf.dist = Mathf.Abs(dist);
cf.face = t;
bool inserted = false;
for ( int k = 0; k < closefaces.Count; k++ )
{
if ( cf.dist < closefaces[k].dist )
{
closefaces.Insert(k, cf);
inserted = true;
break;
}
}
if ( !inserted )
closefaces.Add(cf);
}
}
float tweight = 0.0f;
int maxp = maxpoints;
if ( maxp == 0 )
maxp = closefaces.Count;
for ( int j = 0; j < maxp; j++ )
{
if ( j < closefaces.Count )
{
int t = closefaces[j].face;
if ( targetIsSkin && !sourceIsSkin )
{
p0 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t]));
p1 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t + 1]));
p2 = modobj.transform.InverseTransformPoint(GetSkinPos(basefaces[t + 2]));
}
else
{
p0 = baseverts[basefaces[t]];
p1 = baseverts[basefaces[t + 1]];
p2 = baseverts[basefaces[t + 2]];
}
Vector3 normal = FaceNormal(p0, p1, p2);
float dist = closefaces[j].dist; //GetDistance(p, p0, p1, p2);
MegaBindInf bi = new MegaBindInf();
bi.dist = GetPlaneDistance(p, p0, p1, p2); //dist;
bi.face = t;
bi.i0 = basefaces[t];
bi.i1 = basefaces[t + 1];
bi.i2 = basefaces[t + 2];
bi.bary = CalcBary(p, p0, p1, p2);
bi.weight = 1.0f / (1.0f + dist);
bi.area = normal.magnitude * 0.5f; //CalcArea(baseverts[basefaces[t]], baseverts[basefaces[t + 1]], baseverts[basefaces[t + 2]]); // Could calc once at start
tweight += bi.weight;
bv.verts.Add(bi);
}
}
if ( maxpoints > 0 && maxpoints < bv.verts.Count )
bv.verts.RemoveRange(maxpoints, bv.verts.Count - maxpoints);
// Only want to calculate skin vertices we use
if ( !sourceIsSkin && targetIsSkin )
{
for ( int fi = 0; fi < bv.verts.Count; fi++ )
{
if ( !neededVerts.Contains(bv.verts[fi].i0) )
neededVerts.Add(bv.verts[fi].i0);
if ( !neededVerts.Contains(bv.verts[fi].i1) )
neededVerts.Add(bv.verts[fi].i1);
if ( !neededVerts.Contains(bv.verts[fi].i2) )
neededVerts.Add(bv.verts[fi].i2);
}
}
if ( tweight == 0.0f )
nomapcount++;
bv.weight = tweight;
}
}
public void Attach(MegaModifyObject modobj)
{
if ( mesh && startverts != null )
mesh.vertices = startverts;
if ( modobj == null )
{
bindverts = null;
return;
}
nomapcount = 0;
if ( mesh )
mesh.vertices = startverts;
MeshFilter mf = GetComponent<MeshFilter>();
Mesh srcmesh = null;
if ( mf != null )
{
skinned = false;
srcmesh = mf.mesh;
}
else
{
SkinnedMeshRenderer smesh = (SkinnedMeshRenderer)GetComponent(typeof(SkinnedMeshRenderer));
if ( smesh != null )
{
skinned = true;
srcmesh = smesh.sharedMesh;
}
}
if ( mesh == null )
mesh = CloneMesh(srcmesh); //mf.mesh);
if ( mf )
mf.mesh = mesh;
else
{
SkinnedMeshRenderer smesh = (SkinnedMeshRenderer)GetComponent(typeof(SkinnedMeshRenderer));
smesh.sharedMesh = mesh;
}
//Mesh basemesh = MegaUtils.GetMesh(go);
verts = mesh.vertices;
startverts = mesh.vertices;
freeverts = new Vector3[startverts.Length];
Vector3[] baseverts = modobj.verts; //basemesh.vertices;
int[] basefaces = modobj.tris; //basemesh.triangles;
bindverts = new MegaBindVert[verts.Length];
// matrix to get vertex into local space of target
Matrix4x4 tm = transform.localToWorldMatrix * modobj.transform.worldToLocalMatrix;
List<MegaCloseFace> closefaces = new List<MegaCloseFace>();
for ( int i = 0; i < verts.Length; i++ )
{
//Debug.Log("i " + i + " " + verts[i]);
MegaBindVert bv = new MegaBindVert();
bindverts[i] = bv;
Vector3 p = tm.MultiplyPoint(verts[i]);
//Debug.Log("p " + p);
p = transform.TransformPoint(verts[i]);
p = modobj.transform.InverseTransformPoint(p);
freeverts[i] = p;
//Debug.Log("p " + p);
closefaces.Clear();
for ( int t = 0; t < basefaces.Length; t += 3 )
{
Vector3 p0 = baseverts[basefaces[t]];
Vector3 p1 = baseverts[basefaces[t + 1]];
Vector3 p2 = baseverts[basefaces[t + 2]];
//Vector3 normal = FaceNormal(p0, p1, p2);
float dist = GetDistance(p, p0, p1, p2);
if ( Mathf.Abs(dist) < maxdist )
{
MegaCloseFace cf = new MegaCloseFace();
cf.dist = Mathf.Abs(dist);
cf.face = t;
bool inserted = false;
for ( int k = 0; k < closefaces.Count; k++ )
{
if ( cf.dist < closefaces[k].dist )
{
closefaces.Insert(k, cf);
inserted = true;
break;
}
}
if ( !inserted )
{
closefaces.Add(cf);
}
}
}
float tweight = 0.0f;
int maxp = maxpoints;
if ( maxp == 0 )
{
maxp = closefaces.Count;
}
for ( int j = 0; j < maxp; j++ )
{
int t = closefaces[j].face;
Vector3 p0 = baseverts[basefaces[t]];
Vector3 p1 = baseverts[basefaces[t + 1]];
Vector3 p2 = baseverts[basefaces[t + 2]];
//Debug.Log("Face " + p0 + " " + p1 + " " + p2);
Vector3 normal = FaceNormal(p0, p1, p2);
//float dot = Vector3.Dot(normal, p - p0);
#if true
//Debug.Log("Dot " + dot);
//if ( dot > 0.0f )
{
float dist = closefaces[j].dist; //GetDistance(p, p0, p1, p2);
//Debug.Log("Dist " + dist);
//if ( dist >= 0.0f && dist < maxdist )
//if ( Mathf.Abs(dist) < maxdist )
{
MegaBindInf bi = new MegaBindInf();
bi.dist = GetPlaneDistance(p, p0, p1, p2); //dist;
bi.face = t;
bi.i0 = basefaces[t];
bi.i1 = basefaces[t + 1];
bi.i2 = basefaces[t + 2];
bi.bary = CalcBary(p, p0, p1, p2);
//Debug.Log("Bary " + bi.bary);
bi.weight = 1.0f / (1.0f + dist);
bi.area = normal.magnitude * 0.5f; //CalcArea(baseverts[basefaces[t]], baseverts[basefaces[t + 1]], baseverts[basefaces[t + 2]]); // Could calc once at start
//Debug.Log("Weight " + bi.weight + " area " + bi.area);
tweight += bi.weight;
bv.verts.Add(bi);
//if ( maxpoints > 0 && bv.verts.Count >= maxpoints )
// break;
}
}
#endif
}
if ( maxpoints > 0 )
{
bv.verts.RemoveRange(maxpoints, bv.verts.Count - maxpoints);
}
if ( tweight == 0.0f )
{
nomapcount++;
}
//Debug.Log("TWeight " + tweight);
bv.weight = tweight;
}
// for each vert, find faces that are close enough and thatvert is above
// find closest point on that face
// calc bary coord and find distance from plane of face
// calc area of face for weighting
// keep track of all faces in range for combined weight
}
