public bool LeaveHand(float timestamp, bool mirrored)
{
ContactModule contact = GetContactModule();
if (contact == null)
{
return(false);
}
float shootPeriod = 1.0f;
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
Frame next = contact.GetNextContactEnd(Data.GetFrame(timestamp), mirrored, left, right);
Frame previous = contact.GetPreviousContactEnd(Data.GetFrame(timestamp), mirrored, left, right);
if (next != null && next.Timestamp - timestamp <= shootPeriod)
{
return(true);
}
if (left.GetContact(timestamp, mirrored) == 0f && right.GetContact(timestamp, mirrored) == 0f &&
previous != null && timestamp - previous.Timestamp <= shootPeriod)
{
return(true);
}
return(false);
}
public static void RenderContact(HtmlWriter writer, ContactModule module, bool showHeader)
{
writer.RenderBeginTag(HtmlTextWriterTag.Div, "thumbnail contact");
if (showHeader)
writer.RenderFullTag(HtmlTextWriterTag.H3, "Kontakt");
writer.AddAttribute(HtmlTextWriterAttribute.Src, module.Image.Url);
writer.AddAttribute(HtmlTextWriterAttribute.Alt, module.FullName);
writer.RenderImageTag(module.Image.Url, module.FullName, null);
writer.RenderBeginTag(HtmlTextWriterTag.Div, "caption");
writer.RenderBeginTag(HtmlTextWriterTag.H5);
writer.Write(module.FullName);
writer.RenderEndTag(); // h5
writer.RenderBeginTag(HtmlTextWriterTag.P);
WriteContactInfo(writer, module.Title);
WriteContactInfo(writer, module.Area);
if (!string.IsNullOrEmpty(module.Email))
{
writer.AddAttribute(HtmlTextWriterAttribute.Title, "Email : " + module.Email);
writer.RenderLinkTag("mailto:" + module.Email, "Email : " + module.Email);
writer.WriteBreak();
}
WriteContactInfo(writer, module.Phone, "Tlf.");
WriteContactInfo(writer, module.Mobile, "Mobil");
writer.RenderEndTag(); // p
writer.RenderEndTag(); // div.caption
writer.RenderEndTag(); // div.thumbnail.contact
}
public ContactFunction(ContactModule module, int sensor)
{
Module = module;
Sensor = sensor;
RegularContacts = new bool[Module.Data.GetTotalFrames()];
InverseContacts = new bool[Module.Data.GetTotalFrames()];
Compute();
}
private ContactModule GetContactModule()
{
if (ContactModule == null)
{
ContactModule = Data.GetModule <ContactModule>();
}
return(ContactModule);
}
public Sensor(ContactModule module, string id, int[] bones, Vector3 offset, float threshold, float velocity)
{
Module = module;
ID = id;
Bones = bones;
Offset = offset;
Threshold = threshold;
Velocity = velocity;
Contacts = new float[Module.Data.Frames.Length];
}
public bool IsDribbling(float timestamp, bool mirrored)
{
if (!InsideControlRadius())
{
return(false);
}
ContactModule contact = GetContactModule();
if (contact == null)
{
return(false);
}
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
if (left == null || right == null)
{
return(false);
}
//Check holding contacts
if (left.GetContact(timestamp, mirrored) == 1f && right.GetContact(timestamp, mirrored) == 1f)
{
return(false);
}
//Check dribble contact
if (left.GetContact(timestamp, mirrored) == 1f ^ right.GetContact(timestamp, mirrored) == 1f)
{
return(true);
}
//Check if contact happened before and happens again after within the future and past window
float window = 1f;
Frame previous = contact.GetPreviousContactFrame(Data.GetFrame(timestamp), mirrored, left, right);
if (previous == null || previous.Timestamp < timestamp - window)
{
return(false);
}
Frame next = contact.GetNextContactFrame(Data.GetFrame(timestamp), mirrored, left, right);
if (next != null && next.Timestamp - timestamp <= window)
{
return(left.GetContact(next.Timestamp, mirrored) == 1f ^ right.GetContact(next.Timestamp, mirrored) == 1f);
}
return(false);
bool InsideControlRadius()
{
RootModule root = GetRootModule();
if (root == null)
{
return(false);
}
return(Vector3.Distance(root.GetRootPosition(timestamp, mirrored).ZeroY(), GetBallPosition(timestamp, mirrored).ZeroY()) <= GetControlRadius());
}
}
public Skype4Sharp(SkypeCredentials loginData, WebProxy loginProxy = null)
{
authInfo = loginData;
mainProxy = loginProxy;
mainFactory = new WebRequestFactory(mainProxy, new CookieContainer());
mainPoll = new Poller(this);
selfProfile = new User(this);
mainUserModule = new UserModule(this);
mainAuthModule = new AuthModule(this);
mainMessageModule = new MessageModule(this);
mainContactModule = new ContactModule(this);
}
public Skype4Sharp(Tokens tokens)
{
authTokens = tokens;
mainCookies = new CookieContainer();
mainFactory = new HttpRequestFactory();
mainPoll = new Poller(this);
selfProfile = new User(this);
mainUserModule = new UserModule(this);
mainAuthModule = new AuthModule(this);
mainMessageModule = new MessageModule(this);
mainContactModule = new ContactModule(this);
}
public Skype4Sharp(SkypeCredentials loginData)
{
authInfo = loginData;
mainCookies = new CookieContainer();
mainFactory = new HttpRequestFactory();
mainPoll = new Poller(this);
selfProfile = new User(this);
mainUserModule = new UserModule(this);
mainAuthModule = new AuthModule(this);
mainMessageModule = new MessageModule(this);
mainContactModule = new ContactModule(this);
}
public bool IsHolding(float timestamp, bool mirrored)
{
ContactModule contact = GetContactModule();
if (contact == null)
{
return(false);
}
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
if (left == null || right == null)
{
return(false);
}
return(left.GetContact(timestamp, mirrored) == 1f && right.GetContact(timestamp, mirrored) == 1f);
}
public Sensor(ContactModule module, int bone, Vector3 offset, float threshold, float tolerance, float velocity, ID capture, ID edit)
{
Module = module;
Bone = bone;
Offset = offset;
Threshold = threshold;
Tolerance = tolerance;
Velocity = velocity;
Capture = capture;
Edit = edit;
RegularContacts = new float[Module.Data.Frames.Length];
InverseContacts = new float[Module.Data.Frames.Length];
RegularContactPoints = new Vector3[Module.Data.Frames.Length];
InverseContactPoints = new Vector3[Module.Data.Frames.Length];
RegularDistances = new Vector3[Module.Data.Frames.Length];
InverseDistances = new Vector3[Module.Data.Frames.Length];
}
private bool HasControl(float timestamp, bool mirrored)
{
return(InsideRegion() && HasContact());
bool InsideRegion()
{
RootModule root = GetRootModule();
if (root == null)
{
return(false);
}
return(Vector3.Distance(root.GetRootPosition(timestamp, mirrored).ZeroY(), GetBallPosition(timestamp, mirrored).ZeroY()) <= GetControlRadius());
}
bool HasContact()
{
ContactModule contact = GetContactModule();
if (contact == null)
{
return(false);
}
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
if (left == null || right == null)
{
return(false);
}
float window = 1f;
foreach (Frame f in Data.GetFrames(timestamp - window, timestamp + window))
{
if (contact.HasContact(f, mirrored, left, right))
{
return(true);
}
}
return(false);
}
}
private float ContactPower(float timestamp, bool mirrored)
{
ContactModule contact = GetContactModule();
if (contact == null)
{
return(0f);
}
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
if (left == null || right == null)
{
return(0f);
}
SmoothingWindow = SmoothingWindow == null?Data.GetTimeWindow(MotionEditor.GetInstance().PastWindow + MotionEditor.GetInstance().FutureWindow, 1f) : SmoothingWindow;
SmoothingContacts = SmoothingContacts.Validate(SmoothingWindow.Length);
for (int i = 0; i < SmoothingContacts.Length; i++)
{
SmoothingContacts[i] = left.GetContact(timestamp + SmoothingWindow[i], mirrored) + right.GetContact(timestamp + SmoothingWindow[i], mirrored);
}
return(SmoothingContacts.Gaussian());
}
public ActionResult Edit(ContactModuleViewModel contactModuleViewModel, int pastDisOrder, int pastPosition)
{
if (ModelState.IsValid)
{
Module module = _moduleService.GetById(contactModuleViewModel.ModuleId);
if (module != null)
{
module.ModuleTitle = contactModuleViewModel.ModuleTitle;
module.PositionId = (int)contactModuleViewModel.PositionId;
module.IsActive = contactModuleViewModel.IsActive;
module.Accisibility = contactModuleViewModel.Accisibility;
module.DisplayOrder = contactModuleViewModel.DisplayOrder;
//Method for selecting menus for modules
List <ModulePage> modulePageAddList = new List <ModulePage>();
List <ModulePage> modulePageRemoveList = new List <ModulePage>();
foreach (var item in _menuService.menus())
{
if (Request.Form["Page[" + item.MenuId.ToString() + "]"] != null && !(_modulePageService.ExistModulePage(contactModuleViewModel.ModuleId, item.MenuId)))
{
ModulePage modulePage = new ModulePage()
{
MenuId = item.MenuId,
ModuleId = contactModuleViewModel.ModuleId,
};
modulePageAddList.Add(modulePage);
}
else if (Request.Form["Page[" + item.MenuId.ToString() + "]"] == null && _modulePageService.ExistModulePage(contactModuleViewModel.ModuleId, item.MenuId))
{
ModulePage PageRemove = _modulePageService.GetByMenuModule(contactModuleViewModel.ModuleId, item.MenuId);
modulePageRemoveList.Add(PageRemove);
}
}
_modulePageService.Add(modulePageAddList);
_modulePageService.Delete(modulePageRemoveList);
//editing HtmlModule
ContactModule contactModule = _contactModuleService.GetByModuleId(contactModuleViewModel.ModuleId);
if (contactModule != null)
{
contactModule.Email = contactModuleViewModel.Email;
contactModule.PostCode = contactModuleViewModel.PostCode;
contactModule.PhoneNum = contactModuleViewModel.PhoneNum;
contactModule.MobileNum = contactModuleViewModel.MobileNum;
contactModule.Description = contactModuleViewModel.Description;
contactModule.Address = contactModuleViewModel.Address;
_contactModuleService.Edit(contactModule);
}
//for Users Editing contactModule updating
List <ContactPerson> contactPeopleAddList = new List <ContactPerson>();
List <ContactPerson> contactPeopleRemoveList = new List <ContactPerson>();
foreach (var item in _userService.GetAllAdmin())
{
if (Request.Form["User[" + item.UserId.ToString() + "]"] != null && !(_contactPersonService.ExistContactPerson(contactModuleViewModel.ModuleId, item.UserId)))
{
ContactPerson contactPerson = new ContactPerson()
{
UserId = item.UserId,
ContactModuleId = contactModuleViewModel.ModuleId,
};
contactPeopleAddList.Add(contactPerson);
}
else if (Request.Form["User[" + item.UserId.ToString() + "]"] == null && _contactPersonService.ExistContactPerson(contactModuleViewModel.ModuleId, item.UserId))
{
ContactPerson contactRemove = _contactPersonService.GetByModuleUser(contactModuleViewModel.ModuleId, item.UserId);
contactPeopleRemoveList.Add(contactRemove);
}
}
_contactPersonService.Add(contactPeopleAddList);
_contactPersonService.Delete(contactPeopleRemoveList);
//Editing the Module
_moduleService.Edit(module, pastPosition, pastDisOrder);
}
}
else
{
ModelState.AddModelError(string.Empty, "خطایی وجود دارد");
ViewBag.PositionId = new SelectList(_moduleService.Positions(), "PositionId", "PositionTitle");
return(View());
}
return(RedirectToAction("Index"));
}
public TimeSeries GetTimeSeries(Frame frame, bool mirrored, int pastKeys, int futureKeys, float pastWindow, float futureWindow, int resolution, float delta)
{
TimeSeries timeSeries = new TimeSeries(pastKeys, futureKeys, pastWindow, futureWindow, resolution);
foreach (Module module in Data.Modules)
{
if (module is RootModule)
{
RootModule m = (RootModule)module;
TimeSeries.Root series = new TimeSeries.Root(timeSeries);
for (int i = 0; i < timeSeries.Samples.Length; i++)
{
float t = frame.Timestamp + timeSeries.Samples[i].Timestamp;
if (t < 0f || t > Data.GetTotalTime())
{
series.Transformations[i] = m.GetEstimatedRootTransformation(frame, timeSeries.Samples[i].Timestamp, mirrored);
series.Velocities[i] = m.GetEstimatedRootVelocity(frame, timeSeries.Samples[i].Timestamp, mirrored, delta);
}
else
{
series.Transformations[i] = m.GetRootTransformation(Data.GetFrame(t), mirrored);
series.Velocities[i] = m.GetRootVelocity(Data.GetFrame(t), mirrored, delta);
}
}
}
if (module is StyleModule)
{
StyleModule m = (StyleModule)module;
TimeSeries.Style series = new TimeSeries.Style(timeSeries, m.GetNames());
for (int i = 0; i < timeSeries.Samples.Length; i++)
{
float t = frame.Timestamp + timeSeries.Samples[i].Timestamp;
series.Values[i] = m.GetStyles(Data.GetFrame(t));
}
}
if (module is GoalModule)
{
GoalModule m = (GoalModule)module;
TimeSeries.Goal series = new TimeSeries.Goal(timeSeries, m.GetNames());
for (int i = 0; i < timeSeries.Samples.Length; i++)
{
float t = frame.Timestamp + timeSeries.Samples[i].Timestamp;
series.Transformations[i] = m.Target.GetGoalTransformation(frame, timeSeries.Samples[i].Timestamp, mirrored, delta);
series.Values[i] = m.GetActions(Data.GetFrame(t), delta);
}
}
if (module is ContactModule)
{
ContactModule m = (ContactModule)module;
TimeSeries.Contact series = new TimeSeries.Contact(timeSeries, m.GetNames());
for (int i = 0; i < timeSeries.Samples.Length; i++)
{
float t = frame.Timestamp + timeSeries.Samples[i].Timestamp;
series.Values[i] = m.GetContacts(Data.GetFrame(t), mirrored);
}
}
if (module is PhaseModule)
{
PhaseModule m = (PhaseModule)module;
TimeSeries.Phase series = new TimeSeries.Phase(timeSeries);
for (int i = 0; i < timeSeries.Samples.Length; i++)
{
float t = frame.Timestamp + timeSeries.Samples[i].Timestamp;
series.Values[i] = m.GetPhase(Data.GetFrame(t), mirrored);
}
}
}
return(timeSeries);
}
public async Task <IActionResult> Edit(ContactModuleViewModel contactModuleViewModel, int pastDisOrder, int pastPosition)
{
if (ModelState.IsValid)
{
try
{
Module module = await _moduleService.GetById(contactModuleViewModel.ModuleId);
if (module != null)
{
module.ModuleTitle = contactModuleViewModel.ModuleTitle;
module.PositionId = (int)contactModuleViewModel.PositionId;
module.IsActive = contactModuleViewModel.IsActive;
module.Accisibility = contactModuleViewModel.Accisibility;
module.DisplayOrder = contactModuleViewModel.DisplayOrder;
//Method for selecting menus for modules
List <ModulePage> modulePageAddList = new List <ModulePage>();
List <ModulePage> modulePageRemoveList = new List <ModulePage>();
foreach (var item in await _menuService.Menus())
{
if (Request.Form["Page[" + item.MenuId.ToString() + "]"].Any() && !await _modulePageService.ExistModulePage(contactModuleViewModel.ModuleId, item.MenuId))
{
ModulePage modulePage = new ModulePage()
{
MenuId = item.MenuId,
ModuleId = contactModuleViewModel.ModuleId,
};
modulePageAddList.Add(modulePage);
}
else if (!Request.Form["Page[" + item.MenuId.ToString() + "]"].Any() && await _modulePageService.ExistModulePage(contactModuleViewModel.ModuleId, item.MenuId))
{
ModulePage PageRemove = await _modulePageService.GetByMenuModule(contactModuleViewModel.ModuleId, item.MenuId);
modulePageRemoveList.Add(PageRemove);
}
}
await _modulePageService.Add(modulePageAddList);
await _modulePageService.Remove(modulePageRemoveList);
//editing HtmlModule
ContactModule contactModule = await _contactModuleService.GetByModuleId(contactModuleViewModel.ModuleId);
if (contactModule != null)
{
contactModule.Email = contactModuleViewModel.Email;
contactModule.PostCode = contactModuleViewModel.PostCode;
contactModule.PhoneNum = contactModuleViewModel.PhoneNum;
contactModule.MobileNum = contactModuleViewModel.MobileNum;
contactModule.Description = contactModuleViewModel.Description;
contactModule.Address = contactModuleViewModel.Address;
await _contactModuleService.Edit(contactModule);
}
//for Users Editing contactModule updating
List <ContactPerson> contactPeopleAddList = new List <ContactPerson>();
List <ContactPerson> contactPeopleRemoveList = new List <ContactPerson>();
foreach (var item in await _userService.GetAllAdmin())
{
if (Request.Form["User[" + item.UserId.ToString() + "]"].Any() && !await _contactPersonService.ExistContactPerson(contactModuleViewModel.ModuleId, item.UserId))
{
ContactPerson contactPerson = new ContactPerson()
{
UserId = item.UserId,
ContactModuleId = contactModuleViewModel.ModuleId,
};
contactPeopleAddList.Add(contactPerson);
}
else if (!Request.Form["User[" + item.UserId.ToString() + "]"].Any() && await _contactPersonService.ExistContactPerson(contactModuleViewModel.ModuleId, item.UserId))
{
ContactPerson contactRemove = await _contactPersonService.GetByModuleUser(contactModuleViewModel.ModuleId, item.UserId);
contactPeopleRemoveList.Add(contactRemove);
}
}
await _contactPersonService.Add(contactPeopleAddList);
await _contactPersonService.Remove(contactPeopleRemoveList);
//Editing the Module
await _moduleService.Edit(module, pastPosition, pastDisOrder);
}
}
catch (DbUpdateConcurrencyException)
{
return(NotFound());
}
return(RedirectToAction(nameof(Index)));
}
ViewData["PositionId"] = new SelectList(await _positionService.GetAll(), "PositionId", "PositionTitle");
return(View(contactModuleViewModel));
}
public Matrix4x4[] CleanupBallTransformations(bool detectInvalid)
{
bool invalid = IsInvalid();
if (!detectInvalid && invalid)
{
invalid = false;
Debug.LogWarning("Ignored invalid detection in asset " + Data.GetName() + ".");
}
Matrix4x4[] motion = new Matrix4x4[Data.Frames.Length];
for (int i = 0; i < Data.Frames.Length; i++)
{
Matrix4x4 ball = GetTransformation(Ball, Data.Frames[i].Timestamp);
Matrix4x4 root = GetRoot(Data.Frames[i].Timestamp, false);
float radius = GetControlRadius();
if (invalid)
{
//Project Surface
Matrix4x4 head = GetTransformation(Head, Data.Frames[i].Timestamp);
float offset = (head.GetPosition() - root.GetPosition()).ZeroY().magnitude;
Vector3 projection = head.GetPosition() + (radius - offset) * (head.GetRotation() * Axis.GetAxis());
Vector3 position = (root.GetPosition().ZeroY() + radius * (projection - root.GetPosition()).ZeroY().normalized).SetY(projection.y);
position.y = Mathf.Max(position.y, root.GetPosition().y + Radius);
Matrix4x4Extensions.SetPosition(ref ball, position);
}
else
{
//Clamp Magnitude
Matrix4x4Extensions.SetPosition(ref ball, ball.GetPosition().ClampMagnitudeXZ(radius, root.GetPosition()));
}
motion[i] = ball;
}
return(motion);
Matrix4x4 GetTransformation(int bone, float timestamp)
{
float start = Data.GetFirstValidFrame().Timestamp;
float end = Data.GetLastValidFrame().Timestamp;
if (timestamp < start || timestamp > end)
{
float boundary = Mathf.Clamp(timestamp, start, end);
float pivot = 2f * boundary - timestamp;
float clamped = Mathf.Clamp(pivot, start, end);
Matrix4x4 reference = Data.GetFrame(clamped).GetBoneTransformation(bone, false);
Vector3 position = 2f * Data.GetFrame(boundary).GetBoneTransformation(bone, false).GetPosition() - reference.GetPosition();
position.y = reference.GetPosition().y;
Quaternion rotation = reference.GetRotation();
return(Matrix4x4.TRS(position, rotation, Vector3.one));
}
else
{
return(Data.GetFrame(timestamp).GetBoneTransformation(bone, false));
}
}
bool IsInvalid()
{
//Get Range
int start = Data.GetFirstValidFrame().Index - 1;
int end = Data.GetLastValidFrame().Index - 1;
//Check contacts
ContactModule contact = GetContactModule();
if (contact == null)
{
return(false);
}
ContactModule.Sensor left = contact.GetSensor(Data.Source.Bones[LeftHand].Name);
ContactModule.Sensor right = contact.GetSensor(Data.Source.Bones[RightHand].Name);
if (left != null && right != null)
{
float[] leftContacts = left.Contacts.GatherByPivots(start, end);
float[] rightContacts = left.Contacts.GatherByPivots(start, end);
if (leftContacts.All(1f, 0.9f) ^ rightContacts.All(1f, 0.9f) && !ArrayExtensions.Equal(leftContacts, rightContacts).All(true, 0.1f))
{
Debug.LogWarning("Stuck-to-hand invalidation in file " + Data.GetName() + ".");
return(true);
}
}
//Check transformations
Matrix4x4[] transformations = new Matrix4x4[Data.Frames.Length];
for (int i = 0; i < Data.Frames.Length; i++)
{
transformations[i] = Data.Frames[i].GetBoneTransformation(Ball, false);
}
if (transformations.GatherByPivots(start, end).Repeating(0.9f))
{
Debug.LogWarning("Repeating ball transformation invalidation in file " + Data.GetName() + ".");
return(true);
}
//Check velocities
Vector3[] velocities = new Vector3[Data.Frames.Length];
for (int i = 0; i < Data.Frames.Length; i++)
{
velocities[i] = Data.Frames[i].GetBoneVelocity(Ball, false);
}
if (velocities.GatherByPivots(start, end).Repeating(0.9f))
{
Debug.LogWarning("Ball velocity invalidation in file " + Data.GetName() + ".");
return(true);
}
// //Check out-of-bounds
// bool[] bounds = new bool[Data.Frames.Length];
// for(int i=0; i<Data.Frames.Length; i++) {
// bounds[i] = Vector3.Distance(GetRoot(Data.Frames[i].Timestamp, false).GetPosition(), Data.Frames[i].GetBoneTransformation(Ball, false).GetPosition()) > 0.5f*GetInteractionArea();
// }
// if(bounds.All(true, 0.9f)) {
// return true;
// }
//All seems good
return(false);
}
}
private IEnumerator Process()
{
if (Editor != null)
{
Processing = true;
foreach (Asset a in Assets)
{
a.Processed = false;
}
int count = 0;
if (Pipeline == PIPELINE.Basketball)
{
string referenceBone = string.Empty;
MotionData referenceData = null;
foreach (Asset a in Assets)
{
if (a.Selected)
{
count += 1;
MotionData data = OfflineProcessing ? Editor.GetAsset(a.GUID) : Editor.LoadData(a.GUID);
while (!OfflineProcessing && !data.GetScene().isLoaded)
{
Debug.Log("Waiting for scene being loaded...");
yield return(new WaitForSeconds(0f));
}
//START OF PROCESSING
// Reset motion data
foreach (Frame frame in data.Frames)
{
frame.ResetTransformations();
}
// Global
data.RemoveAllModules();
data.MirrorAxis = Axis.ZPositive;
// 1on1 Ball Copying
{
string GetID(MotionData asset)
{
return(asset.GetName().Substring(0, asset.GetName().LastIndexOf("_P0")));
}
referenceBone = "Player 01:Ball";
if (data.GetName().Contains("_P0"))
{
if (data.GetName().Contains("_P01"))
{
referenceData = data;
}
else if (GetID(data) == GetID(referenceData))
{
data.SampleTransformations(referenceData, referenceBone);
}
else
{
Debug.LogError("Skipping asset " + data.GetName() + " as information of P01 is not of same capture.");
}
}
else
{
Debug.LogError("Skipping asset " + data.GetName() + " as it does not contain player information.");
}
}
{
RootModule root = data.AddModule <RootModule>();
root.Root = data.Source.FindBone("Player 01:Hips").Index;
root.RightShoulder = data.Source.FindBone("Player 01:LeftShoulder").Index;
root.LeftShoulder = data.Source.FindBone("Player 01:RightShoulder").Index;
root.RightHip = data.Source.FindBone("Player 01:LeftUpLeg").Index;
root.LeftHip = data.Source.FindBone("Player 01:RightUpLeg").Index;
root.Neck = data.Source.FindBone("Player 01:Neck").Index;
root.Hips = data.Source.FindBone("Player 01:Hips").Index;
root.Smooth = true;
root.Topology = RootModule.TOPOLOGY.Biped;
root.ForwardAxis = Axis.XPositive;
}
{
ContactModule contact = data.AddModule <ContactModule>();
contact.Clear();
contact.AddSensor("Player 01:LeftFootEnd", "Player 01:LeftFootEnd", Vector3.zero, 0.075f, 1f, -1);
contact.AddSensor("Player 01:RightFootEnd", "Player 01:RightFootEnd", Vector3.zero, 0.075f, 1f, -1);
contact.AddSensor("Player 01:LeftHand", "Player 01:LeftHand", new Vector3(-0.1f, 0f, 0f), 0.075f, 0f, -1);
contact.AddSensor("Player 01:RightHand", "Player 01:RightHand", new Vector3(-0.1f, 0f, 0f), 0.075f, 0f, -1);
contact.AddSensor("Player 01:Ball", "Player 01:Ball", Vector3.zero, 0.2f, 0f, LayerMask.GetMask("Ground"));
contact.CaptureContacts(Editor);
}
{
DribbleModule dribble = data.AddModule <DribbleModule>();
dribble.Area = 2.5f;
dribble.Radius = 0.125f;
dribble.Axis = Axis.YPositive;
Matrix4x4[] motion = dribble.CleanupBallTransformations(false);
for (int i = 0; i < data.Frames.Length; i++)
{
data.Frames[i].Transformations[dribble.Ball] = motion[i];
}
data.GetModule <ContactModule>().CaptureContacts(Editor);
}
{
StyleModule style = data.AddModule <StyleModule>();
RootModule root = data.GetModule <RootModule>();
DribbleModule dribble = data.GetModule <DribbleModule>();
style.Clear();
StyleModule.StyleFunction standing = style.AddStyle("Stand");
StyleModule.StyleFunction moving = style.AddStyle("Move");
StyleModule.StyleFunction dribbling = style.AddStyle("Dribble");
StyleModule.StyleFunction holding = style.AddStyle("Hold");
StyleModule.StyleFunction shooting = style.AddStyle("Shoot");
float threshold = 1f;
for (int f = 0; f < data.Frames.Length; f++)
{
float[] timestamps = data.SimulateTimestamps(data.Frames[f], 30);
float[] weights = new float[timestamps.Length];
for (int j = 0; j < timestamps.Length; j++)
{
weights[j] = Mathf.Clamp(root.GetRootVelocity(timestamps[j], false).magnitude, 0f, threshold);
weights[j] = weights[j].Normalize(0f, threshold, 0, 1f);
weights[j] = weights[j].SmoothStep(2f, 0.5f);
}
float weight = weights.Gaussian().SmoothStep(2f, 0.5f);
standing.Values[f] = 1f - weight;
moving.Values[f] = weight;
dribbling.Values[f] = dribble.IsDribbling(data.Frames[f].Timestamp, false) ? 1f : 0f;
holding.Values[f] = dribble.IsHolding(data.Frames[f].Timestamp, false) ? 1f : 0f;
shooting.Values[f] = dribble.IsShooting(data.Frames[f].Timestamp, false) ? 1f : 0f;
}
style.Mode = StyleModule.DRAWING.Frames;
style.GenerateKeys();
}
{
PhaseModule phase = data.AddModule <PhaseModule>();
ContactModule contact = data.GetModule <ContactModule>();
phase.Inspect = true;
phase.SetFunctions(contact.GetNames());
phase.ShowNormalized = true;
phase.ShowHighlighted = true;
phase.ShowValues = true;
phase.ShowFitting = true;
phase.ShowZero = true;
phase.ShowPhase = true;
phase.ShowWindow = false;
phase.DisplayValues = false;
phase.MaxIterations = 50;
phase.Individuals = 50;
phase.Elites = 5;
phase.Exploration = 0.2f;
phase.Memetism = 0.1f;
phase.MaxFrequency = 4f;
phase.RescalingMethod = PhaseModule.Rescaling.Window;
phase.ApplyButterworth = true;
phase.StartFitting();
while (phase.IsFitting())
{
yield return(new WaitForSeconds(0f));
}
}
//END OF PROCESSING
data.MarkDirty();
a.Processed = true;
}
}
foreach (Asset a in Assets)
{
if (a.Selected)
{
MotionData data = Editor.LoadData(a.GUID);
while (!data.GetScene().isLoaded)
{
Debug.Log("Waiting for scene being loaded...");
yield return(new WaitForSeconds(0f));
}
//START OF PROCESSING
data.GetModule <DribbleModule>().ComputeInteraction();
//END OF PROCESSING
if (SaveAfterProcessing)
{
data.MarkDirty(true, !OfflineProcessing);
}
a.Processed = true;
yield return(new WaitForSeconds(0f));
}
}
if (SaveAfterProcessing)
{
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
if (Pipeline == PIPELINE.Quadruped)
{
foreach (Asset a in Assets)
{
if (a.Selected)
{
count += 1;
MotionData data = OfflineProcessing ? Editor.GetAsset(a.GUID) : Editor.LoadData(a.GUID);
while (!OfflineProcessing && !data.GetScene().isLoaded)
{
Debug.Log("Waiting for scene being loaded...");
yield return(new WaitForSeconds(0f));
}
// START OF PROCESSING
// Reset motion data
foreach (Frame frame in data.Frames)
{
frame.ResetTransformations();
}
// Global
data.RemoveAllModules();
data.Scale = 0.01f;
data.MirrorAxis = Axis.ZPositive;
data.Source.FindBone("Head").Alignment = new Vector3(90f, 0f, 0f);
data.Source.FindBone("Tail").Alignment = new Vector3(-45f, 0f, 0f);
data.Source.FindBone("Tail1").Alignment = new Vector3(-45f, 0f, 0f);
data.Source.FindBone("Tail1Site").Alignment = new Vector3(-45f, 0f, 0f);
{
ContactModule contact = data.AddModule <ContactModule>();
contact.Clear();
contact.AddSensor("Hips", "Hips", Vector3.zero, 0.2f, 1f, LayerMask.GetMask("Ground"));
contact.AddSensor("Neck", "Neck", Vector3.zero, 0.25f, 1f, LayerMask.GetMask("Ground"));
contact.AddSensor("LeftHandSite", new string[] { "LeftForeArm", "LeftHandSite" }, Vector3.zero, 1f / 30f, 1f, LayerMask.GetMask("Ground"));
contact.AddSensor("RightHandSite", new string[] { "RightForeArm", "RightHandSite" }, Vector3.zero, 1f / 30f, 1f, LayerMask.GetMask("Ground"));
contact.AddSensor("LeftFootSite", "LeftFootSite", Vector3.zero, 1f / 30f, 1f, LayerMask.GetMask("Ground"));
contact.AddSensor("RightFootSite", "RightFootSite", Vector3.zero, 1f / 30f, 1f, LayerMask.GetMask("Ground"));
contact.CaptureContacts(Editor);
}
{
StyleModule style = data.AddModule <StyleModule>();
RootModule root = data.AddModule <RootModule>();
root.Topology = RootModule.TOPOLOGY.Quadruped;
ContactModule contact = data.GetModule <ContactModule>();
style.Clear();
StyleModule.StyleFunction idling = style.AddStyle("Idle");
StyleModule.StyleFunction moving = style.AddStyle("Move");
StyleModule.StyleFunction sitting = style.AddStyle("Sit");
StyleModule.StyleFunction resting = style.AddStyle("Rest");
StyleModule.StyleFunction standing = style.AddStyle("Stand");
StyleModule.StyleFunction jumping = style.AddStyle("Jump");
StyleModule.StyleFunction speed = style.AddStyle("Speed");
float[] timeWindow = data.GetTimeWindow(MotionEditor.GetInstance().PastWindow + MotionEditor.GetInstance().FutureWindow, 1f);
float[] contactHeights = new float[data.Frames.Length];
List <float[]> sitPatterns = new List <float[]>()
{
new float[] { 1f, 0f, 1f, 1f, 1f, 1f },
new float[] { 1f, 0f, 0f, 1f, 1f, 1f },
new float[] { 1f, 0f, 1f, 0f, 1f, 1f }
};
List <float[]> restPatterns = new List <float[]>()
{
new float[] { 1f, 1f, 1f, 1f, 1f, 1f }
};
List <float[]> standPatterns = new List <float[]>()
{
new float[] { 1f, 0f, 0f, 0f, 1f, 1f }
};
List <float[]> jumpPatterns = new List <float[]>()
{
new float[] { 0f, 0f, 0f, 0f, 0f, 0f }
};
for (int i = 0; i < data.Frames.Length; i++)
{
for (int j = 0; j < contact.Sensors.Length; j++)
{
contactHeights[i] += data.Frames[i].GetBoneTransformation(contact.Sensors[j].Bones.Last(), false).GetPosition().y;
}
contactHeights[i] /= contact.Sensors.Length;
}
for (int f = 0; f < data.Frames.Length; f++)
{
float weight = GetMovementWeight(data.Frames[f].Timestamp, 0.5f, 0.5f);
idling.Values[f] = 1f - weight;
moving.Values[f] = weight;
float sit = GetContactsWeight(data.Frames[f].Timestamp, 0.5f, contact, sitPatterns, 0f, 1f);
float rest = GetContactsWeight(data.Frames[f].Timestamp, 0.5f, contact, restPatterns, 0f, 1f);
float stand = GetContactsWeight(data.Frames[f].Timestamp, 0.5f, contact, standPatterns, 0f, 1f);
float jump = GetContactsWeight(data.Frames[f].Timestamp, 0.5f, contact, jumpPatterns, 0.3f, 0.1f);
float[] actions = new float[] { sit, rest, stand, jump };
Utility.SoftMax(ref actions);
sitting.Values[f] = sit;
resting.Values[f] = rest;
standing.Values[f] = stand;
jumping.Values[f] = jump;
speed.Values[f] = GetRootSpeed(data.Frames[f].Timestamp);
}
float GetRootSpeed(float timestamp)
{
return(Compute());
float Compute()
{
Vector3[] positions = new Vector3[timeWindow.Length];
for (int i = 0; i < timeWindow.Length; i++)
{
positions[i] = root.GetRootPosition(timestamp + timeWindow[i], false);
}
float length = 0f;
for (int i = 1; i < positions.Length; i++)
{
length += Vector3.Distance(positions[i - 1], positions[i]);
}
return(length / (timeWindow.Last() - timeWindow.First()));
}
}
float GetMovementWeight(float timestamp, float window, float threshold)
{
float[] weights = new float[timeWindow.Length];
for (int j = 0; j < timeWindow.Length; j++)
{
weights[j] = Mathf.Clamp(root.GetRootVelocity(timestamp + timeWindow[j], false).magnitude, 0f, threshold) / threshold;
}
float[] gradients = new float[weights.Length - 1];
for (int i = 0; i < gradients.Length; i++)
{
gradients[i] = (weights[i + 1] - weights[i]) / (timeWindow[i + 1] - timeWindow[i]);
}
float gradient = Mathf.Abs(gradients.Gaussian());
return(weights.Gaussian(gradient).SmoothStep(2f, 0.5f));
}
float GetContactsWeight(float timestamp, float window, ContactModule module, List <float[]> patterns, float heightThreshold, float power)
{
float ContactGaussian(float t)
{
float[] weights = new float[timeWindow.Length];
for (int j = 0; j < timeWindow.Length; j++)
{
bool match = false;
for (int i = 0; i < patterns.Count; i++)
{
float[] contacts = module.GetContacts(t + timeWindow[j], false);
match = ArrayExtensions.Equal(contacts, patterns[i]).All(true);
if (match)
{
break;
}
}
if (match && heightThreshold != 0f && contactHeights[data.GetFrame(t).Index - 1] < heightThreshold)
{
match = false;
}
weights[j] = match ? 1f : 0f;
}
return(weights.Gaussian());
}
float weight = ContactGaussian(timestamp);
weight = Mathf.Pow(weight, 1f - weight);
return(Mathf.Pow(weight, power));
}
style.Mode = StyleModule.DRAWING.Frames;
}
{
PhaseModule phase = data.AddModule <PhaseModule>();
phase.Inspect = true;
RootModule root = data.GetModule <RootModule>();
ContactModule contact = data.GetModule <ContactModule>();
phase.SetFunctions(contact.GetNames());
phase.ShowNormalized = true;
phase.ShowHighlighted = true;
phase.ShowValues = true;
phase.ShowFitting = true;
phase.ShowZero = true;
phase.ShowPhase = true;
phase.ShowWindow = false;
phase.DisplayValues = false;
phase.MaxIterations = 50;
phase.Individuals = 100;
phase.Elites = 10;
phase.Exploration = 0.2f;
phase.Memetism = 0.1f;
phase.MaxFrequency = 4f;
phase.RescalingMethod = PhaseModule.Rescaling.Window;
phase.ApplyButterworth = true;
phase.StartFitting();
while (phase.IsFitting())
{
yield return(new WaitForSeconds(0f));
}
}
//END OF PROCESSING
if (SaveAfterProcessing)
{
data.MarkDirty(true, !OfflineProcessing);
}
a.Processed = true;
yield return(new WaitForSeconds(0f));
}
}
for (int i = 0; i < Editor.Assets.Length; i++)
{
Editor.GetAsset(i).ResetSequences();
Editor.GetAsset(i).Export = false;
}
Editor.GetAsset(0).Export = true;
Editor.GetAsset(0).SetSequence(0, 180, 1531);
Editor.GetAsset(2).Export = true;
Editor.GetAsset(2).SetSequence(0, 680, 820);
Editor.GetAsset(6).Export = true;
Editor.GetAsset(6).SetSequence(0, 90, 593);
Editor.GetAsset(7).Export = true;
Editor.GetAsset(7).SetSequence(0, 290, 1072);
Editor.GetAsset(8).Export = true;
Editor.GetAsset(8).SetSequence(0, 1, 50);
Editor.GetAsset(8).SetSequence(1, 400, 911);
Editor.GetAsset(9).Export = true;
Editor.GetAsset(10).Export = true;
Editor.GetAsset(10).SetSequence(0, 230, 548);
Editor.GetAsset(11).Export = true;
Editor.GetAsset(11).SetSequence(0, 400, 567);
Editor.GetAsset(12).Export = true;
Editor.GetAsset(13).Export = true;
Editor.GetAsset(14).Export = true;
Editor.GetAsset(16).Export = true;
Editor.GetAsset(16).SetSequence(0, 200, 550);
Editor.GetAsset(17).Export = true;
Editor.GetAsset(17).SetSequence(0, 470, 720);
Editor.GetAsset(18).Export = true;
Editor.GetAsset(18).SetSequence(0, 175, 395);
Editor.GetAsset(19).Export = true;
Editor.GetAsset(19).SetSequence(0, 300, 750);
Editor.GetAsset(19).SetSequence(1, 1040, 1079);
Editor.GetAsset(20).Export = true;
Editor.GetAsset(21).Export = true;
Editor.GetAsset(21).SetSequence(0, 1, 1300);
Editor.GetAsset(21).SetSequence(1, 2950, 3530);
Editor.GetAsset(21).SetSequence(2, 3730, 4200);
Editor.GetAsset(22).Export = true;
Editor.GetAsset(23).Export = true;
Editor.GetAsset(23).Export = true;
Editor.GetAsset(24).Export = true;
Editor.GetAsset(24).SetSequence(0, 200, 630);
Editor.GetAsset(25).Export = true;
Editor.GetAsset(25).SetSequence(0, 1, 2690);
Editor.GetAsset(25).SetSequence(1, 2760, 4336);
Editor.GetAsset(26).Export = true;
Editor.GetAsset(27).Export = true;
Editor.GetAsset(27).SetSequence(0, 1, 1100);
Editor.GetAsset(27).SetSequence(1, 2820, 3940);
Editor.GetAsset(27).SetSequence(2, 4100, 4500);
Editor.GetAsset(27).SetSequence(3, 5660, 6010);
Editor.GetAsset(27).SetSequence(4, 6600, 7200);
Editor.GetAsset(27).SetSequence(5, 12300, 12850);
Editor.GetAsset(27).SetSequence(6, 13200, 13399);
Editor.GetAsset(28).Export = true;
Editor.GetAsset(28).SetSequence(0, 920, 985);
Editor.GetAsset(28).SetSequence(1, 1700, 1907);
Editor.GetAsset(29).Export = true;
Editor.GetAsset(29).SetSequence(0, 250, 790);
Editor.GetAsset(29).SetSequence(1, 970, 1575);
Editor.GetAsset(29).SetSequence(2, 1630, 1750);
Editor.GetAsset(30).Export = true;
Editor.GetAsset(30).SetSequence(0, 1790, 1920);
Editor.GetAsset(30).SetSequence(1, 2070, 2470);
Editor.GetAsset(30).SetSequence(2, 2770, 3025);
Editor.GetAsset(31).Export = true;
Editor.GetAsset(31).SetSequence(0, 170, 500);
Editor.GetAsset(31).SetSequence(1, 1250, 2460);
Editor.GetAsset(31).SetSequence(2, 3040, 3200);
Editor.GetAsset(31).SetSequence(3, 4680, 6550);
Editor.GetAsset(31).SetSequence(4, 7600, 9450);
Editor.GetAsset(31).SetSequence(5, 11540, 11691);
Editor.GetAsset(32).Export = true;
Editor.GetAsset(32).SetSequence(0, 1, 300);
Editor.GetAsset(32).SetSequence(1, 1360, 1540);
Editor.GetAsset(32).SetSequence(2, 2380, 3086);
Editor.GetAsset(33).Export = true;
Editor.GetAsset(33).SetSequence(0, 1, 1170);
Editor.GetAsset(33).SetSequence(1, 1980, 2160);
Editor.GetAsset(33).SetSequence(2, 7830, 8090);
Editor.GetAsset(34).Export = true;
Editor.GetAsset(34).SetSequence(0, 1, 270);
Editor.GetAsset(34).SetSequence(1, 2490, 2856);
Editor.GetAsset(35).Export = true;
Editor.GetAsset(37).Export = true;
Editor.GetAsset(38).Export = true;
Editor.GetAsset(38).SetSequence(0, 3330, 3900);
Editor.GetAsset(39).Export = true;
Editor.GetAsset(39).SetSequence(0, 880, 920);
Editor.GetAsset(39).SetSequence(1, 1280, 5052);
Editor.GetAsset(41).Export = true;
Editor.GetAsset(41).SetSequence(0, 4690, 6190);
Editor.GetAsset(42).Export = true;
Editor.GetAsset(42).SetSequence(0, 900, 3594);
Editor.GetAsset(43).Export = true;
Editor.GetAsset(43).SetSequence(0, 1, 500);
Editor.GetAsset(43).SetSequence(1, 4340, 4577);
Editor.GetAsset(44).Export = true;
Editor.GetAsset(44).SetSequence(0, 1, 700);
Editor.GetAsset(44).SetSequence(1, 950, 2000);
Editor.GetAsset(45).Export = true;
Editor.GetAsset(45).SetSequence(0, 1, 410);
Editor.GetAsset(45).SetSequence(1, 680, 778);
Editor.GetAsset(46).Export = true;
Editor.GetAsset(46).SetSequence(0, 175, 235);
Editor.GetAsset(47).Export = true;
Editor.GetAsset(47).SetSequence(0, 275, 498);
Editor.GetAsset(48).Export = true;
Editor.GetAsset(48).SetSequence(0, 1, 220);
Editor.GetAsset(48).SetSequence(1, 675, 748);
Editor.GetAsset(49).Export = true;
Editor.GetAsset(49).SetSequence(0, 1, 700);
Editor.GetAsset(49).SetSequence(1, 1510, 8300);
Editor.GetAsset(50).Export = true;
Editor.GetAsset(50).SetSequence(0, 200, 1000);
Editor.GetAsset(50).SetSequence(1, 1850, 2100);
Editor.GetAsset(50).SetSequence(2, 4150, 4700);
Editor.GetAsset(50).SetSequence(3, 5030, 5356);
//Mark for saving
for (int i = 0; i < Editor.Assets.Length; i++)
{
Editor.GetAsset(i).MarkDirty(true, false);
}
if (SaveAfterProcessing)
{
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
}
Processing = false;
foreach (Asset a in Assets)
{
a.Processed = false;
}
yield return(new WaitForSeconds(0f));
Debug.Log("Finished processing " + count + " assets.");
}
}
private void ProcessData()
{
for (int i = 0; i < Data.Length; i++)
{
if (Active[i])
{
/*
* for(int s=0; s<Data[i].Sequences.Length; s++) {
* //Idle
* Data[i].Sequences[s].SetStyleCopies("Idle", 0);
* Data[i].Sequences[s].SetTransitionCopies("Idle", 0);
*
* //Walk
* Data[i].Sequences[s].SetStyleCopies("Walk", 0);
* Data[i].Sequences[s].SetTransitionCopies("Walk", 0);
*
* //Pace
* Data[i].Sequences[s].SetStyleCopies("Pace", 0);
* Data[i].Sequences[s].SetTransitionCopies("Pace", 0);
*
* //Trot
* Data[i].Sequences[s].SetStyleCopies("Trot", 6);
* Data[i].Sequences[s].SetTransitionCopies("Trot", 6);
*
* //Canter
* Data[i].Sequences[s].SetStyleCopies("Canter", 1);
* Data[i].Sequences[s].SetTransitionCopies("Canter", 1);
*
* //Jump
* Data[i].Sequences[s].SetStyleCopies("Jump", 9);
* Data[i].Sequences[s].SetTransitionCopies("Jump", 9);
*
* //Sit
* Data[i].Sequences[s].SetStyleCopies("Sit", 0);
* Data[i].Sequences[s].SetTransitionCopies("Sit", 0);
*
* //Stand
* Data[i].Sequences[s].SetStyleCopies("Stand", 0);
* Data[i].Sequences[s].SetTransitionCopies("Stand", 5);
*
* //Lie
* Data[i].Sequences[s].SetStyleCopies("Lie", 0);
* Data[i].Sequences[s].SetTransitionCopies("Lie", 5);
* }
*/
//string path = AssetDatabase.GetAssetPath(Data[i]);
//path = path.Substring(0, path.LastIndexOf(".")) + ".unity";
//SceneAsset scene = AssetDatabase.LoadAssetAtPath<SceneAsset>(path);
//Data[i].Scene = scene;
//Data[i].Sequences[0].SetStart(1);
//Data[i].Sequences[0].SetEnd(Data[i].GetTotalFrames());
//Data[i].RootSmoothing = 10;
//Data[i].AddModule(Module.TYPE.Style);
//Data[i].AddModule(Module.TYPE.Phase);
//StyleModule style = (StyleModule)Data[i].GetModule(Module.TYPE.Style);
//style.Inspect = false;
//style.AddStyle("Idle");
//style.AddStyle("Walk");
//style.AddStyle("Run");
//style.AddStyle("Crouch");
//PhaseModule phase = (PhaseModule)Data[i].GetModule(Module.TYPE.Phase);
//phase.Inspect = false;
//phase.ToggleVariable(Data[i].Source.FindBone("RightToeSite").Index);
//Data[i].Sequences[0].Start = 62;
//Data[i].Sequences[0].End = Data[i].GetTotalFrames();
StyleModule style = (StyleModule)Data[i].GetModule(Module.TYPE.Style);
//style.AddStyle("Jump");
//style.Inspect = true;
for (int j = 0; j < style.Functions.Length; j++)
{
style.Functions[j].Module = style;
}
ContactModule contact = (ContactModule)Data[i].GetModule(ContactModule.TYPE.Contact);
//contact.Inspect = false;
//Data[i].AddModule(Module.TYPE.Contact);
/*
* ContactModule contact = (ContactModule)Data[i].GetModule(ContactModule.TYPE.Contact);
* contact.Inspect = true;
* for(int j=0; j<contact.Functions.Length; j++) {
* contact.Functions[j].SetDistanceThreshold(0.025f);
* contact.Functions[j].SetVelocityThreshold(1f);
* contact.Functions[j].SetFilterWidth(10);
* }
*/
//for(int b=0; b<Data[i].Source.Bones.Length; b++) {
// Data[i].Source.Bones[b].Active = true;
//}
EditorUtility.SetDirty(Data[i]);
}
}
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
}
public void Edit(ContactModule contactModule)
{
_unitOfWork.ContactModuleRepository.Update(contactModule);
_unitOfWork.Save();
}
