public void ModifyCompressed(MegaModifiers mc) { framenum++; mc.ChangeSourceVerts(); float fChannelPercent; Vector3 delt; // cycle through channels, searching for ones to use bool firstchan = true; bool morphed = false; for ( int i = 0; i < chanBank.Count; i++ ) { MegaMorphChan chan = chanBank[i]; chan.UpdatePercent(); fChannelPercent = Mathf.Clamp(chan.Percent, 0.0f, 100.0f); if ( fChannelPercent > 0.0f || (fChannelPercent == 0.0f && chan.fChannelPercent != 0.0f) ) { chan.fChannelPercent = fChannelPercent; if ( chan.mTargetCache != null && chan.mTargetCache.Count > 0 && chan.mActiveOverride ) //&& fChannelPercent != 0.0f ) { morphed = true; //if ( chanBank[i].mapping == null || chanBank[i].mapping.Length == 0 ) //{ //chanBank[i].ChannelMapping(this); //} if ( chan.mUseLimit ) //|| glUseLimit ) { //if ( glUseLimit ) //fChannelPercent = Mathf.Lerp(glMIN, glMAX, fChannelPercent * 0.01f); //else fChannelPercent = Mathf.Lerp(chan.mSpinmin, chan.mSpinmax, fChannelPercent * 0.01f); } // New bit if ( firstchan ) { firstchan = false; // Save a int array of morphedpoints and use that, then only dealing with changed info for ( int pointnum = 0; pointnum < morphedVerts.Length; pointnum++ ) { // this will change when we remove points int p = morphedVerts[pointnum]; dif[p] = oPoints[p]; //morphedVerts[pointnum]]; } } // end new if ( chan.mTargetCache.Count == 1 ) { //MegaMorphChan chan = chanBank[i]; // Compressed version #if false if ( firstchan ) { firstchan = false; // Save a int array of morphedpoints and use that, then only dealing with changed info for ( int pointnum = 0; pointnum < morphedVerts.Length; pointnum++ ) { // this will change when we remove points int p = morphedVerts[pointnum]; dif[p] = oPoints[p]; //morphedVerts[pointnum]]; delt = chan.mDeltas[p]; //morphedVerts[pointnum]]; //delt = chan.mDeltas[pointnum]; //morphedVerts[pointnum]]; dif[p].x += delt.x * fChannelPercent; dif[p].y += delt.y * fChannelPercent; dif[p].z += delt.z * fChannelPercent; } } else #endif { // Save a int array of morphedpoints and use that, then only dealing with changed info for ( int pointnum = 0; pointnum < morphedVerts.Length; pointnum++ ) { int p = morphedVerts[pointnum]; delt = chan.mDeltas[p]; //morphedVerts[pointnum]]; //delt = chan.mDeltas[pointnum]; //morphedVerts[pointnum]]; dif[p].x += delt.x * fChannelPercent; dif[p].y += delt.y * fChannelPercent; dif[p].z += delt.z * fChannelPercent; } } } else { int totaltargs = chan.mTargetCache.Count; // + 1; // + 1; float fProgression = fChannelPercent; //Mathf.Clamp(fChannelPercent, 0.0f, 100.0f); int segment = 1; while ( segment <= totaltargs && fProgression >= chan.GetTargetPercent(segment - 2) ) segment++; if ( segment > totaltargs ) segment = totaltargs; p4 = oPoints; if ( segment == 1 ) { p1 = oPoints; p2 = chan.mTargetCache[0].points; // mpoints p3 = chan.mTargetCache[1].points; } else { if ( segment == totaltargs ) { int targnum = totaltargs - 1; for ( int j = 2; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } else { int targnum = segment; for ( int j = 3; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } float targetpercent1 = chan.GetTargetPercent(segment - 3); float targetpercent2 = chan.GetTargetPercent(segment - 2); float top = fProgression - targetpercent1; float bottom = targetpercent2 - targetpercent1; float u = top / bottom; for ( int pointnum = 0; pointnum < morphedVerts.Length; pointnum++ ) { int p = morphedVerts[pointnum]; Vector3 vert = oPoints[p]; //pointnum]; //if ( firstvert[p] != framenum ) //{ // firstvert[p] = framenum; // dif[p] = oPoints[p]; // Should be verts //} float length; Vector3 progession; endpoint[0] = p1[p]; endpoint[1] = p2[p]; endpoint[2] = p3[p]; endpoint[3] = p4[p]; //endpoint[0] = p1[pointnum]; //endpoint[1] = p2[pointnum]; //endpoint[2] = p3[pointnum]; //endpoint[3] = p4[pointnum]; if ( segment == 1 ) { splinepoint[0] = endpoint[0]; splinepoint[3] = endpoint[1]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[1] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; splinepoint[1] = endpoint[0] + chan.mCurvature * (splinepoint[2] - endpoint[0]); } } else { if ( segment == totaltargs ) { splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[2]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[1] = endpoint[1] - (Vector3.Dot(temppoint[1], temppoint[0]) * chan.mCurvature / length) * temppoint[1]; splinepoint[2] = endpoint[2] + chan.mCurvature * (splinepoint[1] - endpoint[2]); } } else { temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; if ( length == 0.0f ) splinepoint[1] = endpoint[0]; else splinepoint[1] = endpoint[1] + (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; temppoint[1] = endpoint[3] - endpoint[1]; temppoint[0] = endpoint[2] - endpoint[1]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) splinepoint[2] = endpoint[1]; else splinepoint[2] = endpoint[2] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } } MegaUtils.Bez3D(out progession, ref splinepoint, u); dif[p].x += progession.x - vert.x; dif[p].y += progession.y - vert.y; dif[p].z += progession.z - vert.z; } } } } } if ( morphed ) { for ( int i = 0; i < morphMappingFrom.Length; i++ ) sverts[morphMappingTo[i]] = dif[morphMappingFrom[i]]; for ( int i = 0; i < nonMorphMappingFrom.Length; i++ ) sverts[nonMorphMappingTo[i]] = oPoints[nonMorphMappingFrom[i]]; } else { for ( int i = 0; i < verts.Length; i++ ) sverts[i] = verts[i]; } }
// oPoints whould be verts public override void Modify(MegaModifiers mc) { if ( nonMorphedVerts != null && nonMorphedVerts.Length > 1 ) { ModifyCompressed(mc); return; } framenum++; //Vector3[] verts = mc.GetSourceVerts(); mc.ChangeSourceVerts(); //Vector3[] sverts = mc.GetDestVerts(); float fChannelPercent; Vector3 delt; // cycle through channels, searching for ones to use bool firstchan = true; bool morphed = false; float min = 0.0f; float max = 100.0f; if ( UseLimit ) { min = Min; max = Max; } for ( int i = 0; i < chanBank.Count; i++ ) { MegaMorphChan chan = chanBank[i]; chan.UpdatePercent(); //fChannelPercent = Mathf.Clamp(chan.Percent, 0.0f, 100.0f); if ( UseLimit ) { fChannelPercent = Mathf.Clamp(chan.Percent, min, max); //chan.mSpinmin, chan.mSpinmax); } else { if ( chan.mUseLimit ) fChannelPercent = Mathf.Clamp(chan.Percent, chan.mSpinmin, chan.mSpinmax); else fChannelPercent = Mathf.Clamp(chan.Percent, 0.0f, 100.0f); } //if ( fChannelPercent > 0.0f ) if ( fChannelPercent != 0.0f || (fChannelPercent == 0.0f && chan.fChannelPercent != 0.0f) ) { chan.fChannelPercent = fChannelPercent; if ( chan.mTargetCache != null && chan.mTargetCache.Count > 0 && chan.mActiveOverride ) //&& fChannelPercent != 0.0f ) { morphed = true; //if ( chanBank[i].mapping == null || chanBank[i].mapping.Length == 0 ) //{ //chanBank[i].ChannelMapping(this); //} if ( chan.mUseLimit ) //|| glUseLimit ) { //if ( glUseLimit ) //fChannelPercent = Mathf.Lerp(glMIN, glMAX, fChannelPercent * 0.01f); //else ///fChannelPercent = Mathf.Lerp(chan.mSpinmin, chan.mSpinmax, fChannelPercent * 0.01f); } if ( firstchan ) { firstchan = false; //Debug.Log("diflen " + dif.Length + " opoints " + oPoints.Length); for ( int pointnum = 0; pointnum < oPoints.Length; pointnum++ ) { dif[pointnum] = oPoints[pointnum]; } } if ( chan.mTargetCache.Count == 1 ) { //MegaMorphChan chan = chanBank[i]; // Compressed version #if false if ( firstchan ) { firstchan = false; for ( int pointnum = 0; pointnum < oPoints.Length; pointnum++ ) { dif[pointnum] = oPoints[pointnum]; delt = chan.mDeltas[pointnum]; dif[pointnum].x += delt.x * fChannelPercent; dif[pointnum].y += delt.y * fChannelPercent; dif[pointnum].z += delt.z * fChannelPercent; } } else #endif { for ( int pointnum = 0; pointnum < oPoints.Length; pointnum++ ) { delt = chan.mDeltas[pointnum]; dif[pointnum].x += delt.x * fChannelPercent; dif[pointnum].y += delt.y * fChannelPercent; dif[pointnum].z += delt.z * fChannelPercent; } } } else { int totaltargs = chan.mTargetCache.Count; // + 1; // + 1; float fProgression = fChannelPercent; //Mathf.Clamp(fChannelPercent, 0.0f, 100.0f); int segment = 1; while ( segment <= totaltargs && fProgression >= chan.GetTargetPercent(segment - 2) ) segment++; if ( segment > totaltargs ) segment = totaltargs; p4 = oPoints; if ( segment == 1 ) { p1 = oPoints; p2 = chan.mTargetCache[0].points; // mpoints p3 = chan.mTargetCache[1].points; } else { if ( segment == totaltargs ) { int targnum = totaltargs - 1; for ( int j = 2; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } else { int targnum = segment; for ( int j = 3; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } float targetpercent1 = chan.GetTargetPercent(segment - 3); float targetpercent2 = chan.GetTargetPercent(segment - 2); float top = fProgression - targetpercent1; float bottom = targetpercent2 - targetpercent1; float u = top / bottom; { for ( int pointnum = 0; pointnum < oPoints.Length; pointnum++ ) { Vector3 vert = oPoints[pointnum]; //if ( firstvert[pointnum] != framenum ) //{ // firstvert[pointnum] = framenum; // dif[pointnum] = oPoints[pointnum]; //} float length; Vector3 progession; endpoint[0] = p1[pointnum]; endpoint[1] = p2[pointnum]; endpoint[2] = p3[pointnum]; endpoint[3] = p4[pointnum]; if ( segment == 1 ) { splinepoint[0] = endpoint[0]; splinepoint[3] = endpoint[1]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[1] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; splinepoint[1] = endpoint[0] + chan.mCurvature * (splinepoint[2] - endpoint[0]); } } else { if ( segment == totaltargs ) { splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[2]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[1] = endpoint[1] - (Vector3.Dot(temppoint[1], temppoint[0]) * chan.mCurvature / length) * temppoint[1]; splinepoint[2] = endpoint[2] + chan.mCurvature * (splinepoint[1] - endpoint[2]); } } else { temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; if ( length == 0.0f ) splinepoint[1] = endpoint[0]; else splinepoint[1] = endpoint[1] + (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; temppoint[1] = endpoint[3] - endpoint[1]; temppoint[0] = endpoint[2] - endpoint[1]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) splinepoint[2] = endpoint[1]; else splinepoint[2] = endpoint[2] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } } MegaUtils.Bez3D(out progession, ref splinepoint, u); //delt.x = progession.x - vert.x; dif[pointnum].x += progession.x - vert.x; //delt; dif[pointnum].y += progession.y - vert.y; //delt; dif[pointnum].z += progession.z - vert.z; //delt; //PointsMOD[pointnum] = true; } } } } } } if ( morphed ) { for ( int i = 0; i < mapping.Length; i++ ) { sverts[i] = dif[mapping[i]]; } } else { for ( int i = 0; i < verts.Length; i++ ) { sverts[i] = verts[i]; } } }
// oPoints whould be verts public override void Modify(MegaModifiers mc) { if (source == null) { return; } if (source.nonMorphedVerts != null && source.nonMorphedVerts.Length > 1) { ModifyCompressed(mc); return; } framenum++; mc.ChangeSourceVerts(); float fChannelPercent; Vector3 delt; // cycle through channels, searching for ones to use bool firstchan = true; bool morphed = false; float min = 0.0f; float max = 100.0f; if (UseLimit) { min = Min; max = Max; } for (int i = 0; i < source.chanBank.Count; i++) { MegaMorphChan chan = source.chanBank[i]; // This needs to be local chan list chan.UpdatePercent(); if (UseLimit) { fChannelPercent = Mathf.Clamp(chan.Percent, min, max); //chan.mSpinmin, chan.mSpinmax); } else { if (chan.mUseLimit) { fChannelPercent = Mathf.Clamp(chan.Percent, chan.mSpinmin, chan.mSpinmax); } else { fChannelPercent = Mathf.Clamp(chan.Percent, 0.0f, 100.0f); } } if (fChannelPercent != 0.0f || (fChannelPercent == 0.0f && chan.fChannelPercent != 0.0f)) { chan.fChannelPercent = fChannelPercent; if (chan.mTargetCache != null && chan.mTargetCache.Count > 0 && chan.mActiveOverride) //&& fChannelPercent != 0.0f ) { morphed = true; if (chan.mUseLimit) //|| glUseLimit ) { } if (firstchan) { firstchan = false; for (int pointnum = 0; pointnum < source.oPoints.Length; pointnum++) { dif[pointnum] = source.oPoints[pointnum]; } } if (chan.mTargetCache.Count == 1) { for (int pointnum = 0; pointnum < source.oPoints.Length; pointnum++) { delt = chan.mDeltas[pointnum]; dif[pointnum].x += delt.x * fChannelPercent; dif[pointnum].y += delt.y * fChannelPercent; dif[pointnum].z += delt.z * fChannelPercent; } } else { int totaltargs = chan.mTargetCache.Count; // + 1; // + 1; float fProgression = fChannelPercent; //Mathf.Clamp(fChannelPercent, 0.0f, 100.0f); int segment = 1; while (segment <= totaltargs && fProgression >= chan.GetTargetPercent(segment - 2)) { segment++; } if (segment > totaltargs) { segment = totaltargs; } p4 = source.oPoints; if (segment == 1) { p1 = source.oPoints; p2 = chan.mTargetCache[0].points; // mpoints p3 = chan.mTargetCache[1].points; } else { if (segment == totaltargs) { int targnum = totaltargs - 1; for (int j = 2; j >= 0; j--) { targnum--; if (targnum == -2) { SetVerts(j, source.oPoints); } else { SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } else { int targnum = segment; for (int j = 3; j >= 0; j--) { targnum--; if (targnum == -2) { SetVerts(j, source.oPoints); } else { SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } } float targetpercent1 = chan.GetTargetPercent(segment - 3); float targetpercent2 = chan.GetTargetPercent(segment - 2); float top = fProgression - targetpercent1; float bottom = targetpercent2 - targetpercent1; float u = top / bottom; { for (int pointnum = 0; pointnum < source.oPoints.Length; pointnum++) { Vector3 vert = source.oPoints[pointnum]; float length; Vector3 progession; endpoint[0] = p1[pointnum]; endpoint[1] = p2[pointnum]; endpoint[2] = p3[pointnum]; endpoint[3] = p4[pointnum]; if (segment == 1) { splinepoint[0] = endpoint[0]; splinepoint[3] = endpoint[1]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[1] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; splinepoint[1] = endpoint[0] + chan.mCurvature * (splinepoint[2] - endpoint[0]); } } else { if (segment == totaltargs) { splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[2]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[1] = endpoint[1] - (Vector3.Dot(temppoint[1], temppoint[0]) * chan.mCurvature / length) * temppoint[1]; splinepoint[2] = endpoint[2] + chan.mCurvature * (splinepoint[1] - endpoint[2]); } } else { temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; if (length == 0.0f) { splinepoint[1] = endpoint[0]; } else { splinepoint[1] = endpoint[1] + (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } temppoint[1] = endpoint[3] - endpoint[1]; temppoint[0] = endpoint[2] - endpoint[1]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[2] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } } } MegaUtils.Bez3D(out progession, ref splinepoint, u); dif[pointnum].x += progession.x - vert.x; //delt; dif[pointnum].y += progession.y - vert.y; //delt; dif[pointnum].z += progession.z - vert.z; //delt; } } } } } } if (morphed) { for (int i = 0; i < source.mapping.Length; i++) { sverts[i] = dif[source.mapping[i]]; } } else { for (int i = 0; i < verts.Length; i++) { sverts[i] = verts[i]; } } }
public void ModifyCompressed(MegaModifiers mc) { framenum++; mc.ChangeSourceVerts(); float fChannelPercent; Vector3 delt; // cycle through channels, searching for ones to use bool firstchan = true; bool morphed = false; for (int i = 0; i < source.chanBank.Count; i++) { MegaMorphChan chan = source.chanBank[i]; MegaMorphChan lchan = chanBank[i]; // copy of source banks with out the vert data chan.UpdatePercent(); if (chan.mUseLimit) { fChannelPercent = Mathf.Clamp(lchan.Percent, chan.mSpinmin, chan.mSpinmax); } else { fChannelPercent = Mathf.Clamp(lchan.Percent, 0.0f, 100.0f); } if (fChannelPercent != 0.0f || (fChannelPercent == 0.0f && chan.fChannelPercent != 0.0f)) { chan.fChannelPercent = fChannelPercent; if (chan.mTargetCache != null && chan.mTargetCache.Count > 0 && chan.mActiveOverride) //&& fChannelPercent != 0.0f ) { morphed = true; if (chan.mUseLimit) //|| glUseLimit ) { } // New bit if (firstchan) { firstchan = false; // Save a int array of morphedpoints and use that, then only dealing with changed info for (int pointnum = 0; pointnum < source.morphedVerts.Length; pointnum++) { // this will change when we remove points int p = source.morphedVerts[pointnum]; dif[p] = source.oPoints[p]; //morphedVerts[pointnum]]; } } // end new if (chan.mTargetCache.Count == 1) { // Save a int array of morphedpoints and use that, then only dealing with changed info for (int pointnum = 0; pointnum < source.morphedVerts.Length; pointnum++) { int p = source.morphedVerts[pointnum]; delt = chan.mDeltas[p]; //morphedVerts[pointnum]]; //delt = chan.mDeltas[pointnum]; //morphedVerts[pointnum]]; dif[p].x += delt.x * fChannelPercent; dif[p].y += delt.y * fChannelPercent; dif[p].z += delt.z * fChannelPercent; } } else { int totaltargs = chan.mTargetCache.Count; // + 1; // + 1; float fProgression = fChannelPercent; //Mathf.Clamp(fChannelPercent, 0.0f, 100.0f); int segment = 1; while (segment <= totaltargs && fProgression >= chan.GetTargetPercent(segment - 2)) { segment++; } if (segment > totaltargs) { segment = totaltargs; } p4 = source.oPoints; if (segment == 1) { p1 = source.oPoints; p2 = chan.mTargetCache[0].points; // mpoints p3 = chan.mTargetCache[1].points; } else { if (segment == totaltargs) { int targnum = totaltargs - 1; for (int j = 2; j >= 0; j--) { targnum--; if (targnum == -2) { SetVerts(j, source.oPoints); } else { SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } else { int targnum = segment; for (int j = 3; j >= 0; j--) { targnum--; if (targnum == -2) { SetVerts(j, source.oPoints); } else { SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } } float targetpercent1 = chan.GetTargetPercent(segment - 3); float targetpercent2 = chan.GetTargetPercent(segment - 2); float top = fProgression - targetpercent1; float bottom = targetpercent2 - targetpercent1; float u = top / bottom; for (int pointnum = 0; pointnum < source.morphedVerts.Length; pointnum++) { int p = source.morphedVerts[pointnum]; Vector3 vert = source.oPoints[p]; //pointnum]; float length; Vector3 progession; endpoint[0] = p1[p]; endpoint[1] = p2[p]; endpoint[2] = p3[p]; endpoint[3] = p4[p]; if (segment == 1) { splinepoint[0] = endpoint[0]; splinepoint[3] = endpoint[1]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[1] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; splinepoint[1] = endpoint[0] + chan.mCurvature * (splinepoint[2] - endpoint[0]); } } else { if (segment == totaltargs) { splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[2]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[1] = endpoint[1] - (Vector3.Dot(temppoint[1], temppoint[0]) * chan.mCurvature / length) * temppoint[1]; splinepoint[2] = endpoint[2] + chan.mCurvature * (splinepoint[1] - endpoint[2]); } } else { temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; if (length == 0.0f) { splinepoint[1] = endpoint[0]; } else { splinepoint[1] = endpoint[1] + (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } temppoint[1] = endpoint[3] - endpoint[1]; temppoint[0] = endpoint[2] - endpoint[1]; length = temppoint[1].sqrMagnitude; if (length == 0.0f) { splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[2] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } } } MegaUtils.Bez3D(out progession, ref splinepoint, u); dif[p].x += progession.x - vert.x; dif[p].y += progession.y - vert.y; dif[p].z += progession.z - vert.z; } } } } } if (morphed) { for (int i = 0; i < source.morphMappingFrom.Length; i++) { sverts[source.morphMappingTo[i]] = dif[source.morphMappingFrom[i]]; } for (int i = 0; i < source.nonMorphMappingFrom.Length; i++) { sverts[source.nonMorphMappingTo[i]] = source.oPoints[source.nonMorphMappingFrom[i]]; } } else { for (int i = 0; i < verts.Length; i++) { sverts[i] = verts[i]; } } }
// oPoints whould be verts public override void Modify(MegaModifiers mc) { if ( source == null ) return; if ( source.nonMorphedVerts != null && source.nonMorphedVerts.Length > 1 ) { ModifyCompressed(mc); return; } framenum++; mc.ChangeSourceVerts(); float fChannelPercent; Vector3 delt; // cycle through channels, searching for ones to use bool firstchan = true; bool morphed = false; float min = 0.0f; float max = 100.0f; if ( UseLimit ) { min = Min; max = Max; } for ( int i = 0; i < source.chanBank.Count; i++ ) { MegaMorphChan chan = source.chanBank[i]; // This needs to be local chan list chan.UpdatePercent(); if ( UseLimit ) { fChannelPercent = Mathf.Clamp(chan.Percent, min, max); //chan.mSpinmin, chan.mSpinmax); } else { if ( chan.mUseLimit ) fChannelPercent = Mathf.Clamp(chan.Percent, chan.mSpinmin, chan.mSpinmax); else fChannelPercent = Mathf.Clamp(chan.Percent, 0.0f, 100.0f); } if ( fChannelPercent != 0.0f || (fChannelPercent == 0.0f && chan.fChannelPercent != 0.0f) ) { chan.fChannelPercent = fChannelPercent; if ( chan.mTargetCache != null && chan.mTargetCache.Count > 0 && chan.mActiveOverride ) //&& fChannelPercent != 0.0f ) { morphed = true; if ( chan.mUseLimit ) //|| glUseLimit ) { } if ( firstchan ) { firstchan = false; for ( int pointnum = 0; pointnum < source.oPoints.Length; pointnum++ ) { dif[pointnum] = source.oPoints[pointnum]; } } if ( chan.mTargetCache.Count == 1 ) { for ( int pointnum = 0; pointnum < source.oPoints.Length; pointnum++ ) { delt = chan.mDeltas[pointnum]; dif[pointnum].x += delt.x * fChannelPercent; dif[pointnum].y += delt.y * fChannelPercent; dif[pointnum].z += delt.z * fChannelPercent; } } else { int totaltargs = chan.mTargetCache.Count; // + 1; // + 1; float fProgression = fChannelPercent; //Mathf.Clamp(fChannelPercent, 0.0f, 100.0f); int segment = 1; while ( segment <= totaltargs && fProgression >= chan.GetTargetPercent(segment - 2) ) segment++; if ( segment > totaltargs ) segment = totaltargs; p4 = source.oPoints; if ( segment == 1 ) { p1 = source.oPoints; p2 = chan.mTargetCache[0].points; // mpoints p3 = chan.mTargetCache[1].points; } else { if ( segment == totaltargs ) { int targnum = totaltargs - 1; for ( int j = 2; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, source.oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } else { int targnum = segment; for ( int j = 3; j >= 0; j-- ) { targnum--; if ( targnum == -2 ) SetVerts(j, source.oPoints); else SetVerts(j, chan.mTargetCache[targnum + 1].points); } } } float targetpercent1 = chan.GetTargetPercent(segment - 3); float targetpercent2 = chan.GetTargetPercent(segment - 2); float top = fProgression - targetpercent1; float bottom = targetpercent2 - targetpercent1; float u = top / bottom; { for ( int pointnum = 0; pointnum < source.oPoints.Length; pointnum++ ) { Vector3 vert = source.oPoints[pointnum]; float length; Vector3 progession; endpoint[0] = p1[pointnum]; endpoint[1] = p2[pointnum]; endpoint[2] = p3[pointnum]; endpoint[3] = p4[pointnum]; if ( segment == 1 ) { splinepoint[0] = endpoint[0]; splinepoint[3] = endpoint[1]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[2] = endpoint[1] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; splinepoint[1] = endpoint[0] + chan.mCurvature * (splinepoint[2] - endpoint[0]); } } else { if ( segment == totaltargs ) { splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[2]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) { splinepoint[1] = endpoint[0]; splinepoint[2] = endpoint[1]; } else { splinepoint[1] = endpoint[1] - (Vector3.Dot(temppoint[1], temppoint[0]) * chan.mCurvature / length) * temppoint[1]; splinepoint[2] = endpoint[2] + chan.mCurvature * (splinepoint[1] - endpoint[2]); } } else { temppoint[1] = endpoint[2] - endpoint[0]; temppoint[0] = endpoint[1] - endpoint[0]; length = temppoint[1].sqrMagnitude; splinepoint[0] = endpoint[1]; splinepoint[3] = endpoint[2]; if ( length == 0.0f ) splinepoint[1] = endpoint[0]; else splinepoint[1] = endpoint[1] + (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; temppoint[1] = endpoint[3] - endpoint[1]; temppoint[0] = endpoint[2] - endpoint[1]; length = temppoint[1].sqrMagnitude; if ( length == 0.0f ) splinepoint[2] = endpoint[1]; else splinepoint[2] = endpoint[2] - (Vector3.Dot(temppoint[0], temppoint[1]) * chan.mCurvature / length) * temppoint[1]; } } MegaUtils.Bez3D(out progession, ref splinepoint, u); dif[pointnum].x += progession.x - vert.x; //delt; dif[pointnum].y += progession.y - vert.y; //delt; dif[pointnum].z += progession.z - vert.z; //delt; } } } } } } if ( morphed ) { for ( int i = 0; i < source.mapping.Length; i++ ) sverts[i] = dif[source.mapping[i]]; } else { for ( int i = 0; i < verts.Length; i++ ) sverts[i] = verts[i]; } }