public void Bake(apModifiedVertexWeight srcModVertWeight)
{
//>>19.5.23 : 삭제 (불필요)
//_vertexUniqueID = srcModVertWeight._vertexUniqueID;
//_vertIndex = srcModVertWeight._vertIndex;
_isEnabled = srcModVertWeight._isEnabled;
_weight = srcModVertWeight._weight;
//>>19.5.23 : 삭제 (불필요)
//_isPhysics = srcModVertWeight._isPhysics;
//_isVolume = srcModVertWeight._isVolume;
_pos_World_NoMod = srcModVertWeight._pos_World_NoMod;
//>>19.5.23 : 삭제 (불필요)
//_deltaPosRadius_Free = srcModVertWeight._deltaPosRadius_Free;
//_deltaPosRadius_Max = srcModVertWeight._deltaPosRadius_Max;
if (_physicParam == null)
{
_physicParam = new apOptPhysicsVertParam();
}
_physicParam.Bake(srcModVertWeight._physicParam);
}
public void Bake_VertexWeights(apOptTransform rootTransform, apOptTransform targetTransform,
apOptMesh targetMesh, List <apModifiedVertexWeight> modVertWeights)
{
_rootTransform = rootTransform;
_targetTransform = targetTransform;
_targetMesh = targetMesh;
if (_targetMesh == null)
{
Debug.LogError("Vert Rig인데 Target Mesh가 Null");
Debug.LogError("Target Transform [" + _targetTransform.transform.name + "]");
}
_nVertWeights = modVertWeights.Count;
_vertWeights = new apOptModifiedVertexWeight[_nVertWeights];
for (int i = 0; i < _nVertWeights; i++)
{
apOptModifiedVertexWeight optModVertWeight = new apOptModifiedVertexWeight();
apModifiedVertexWeight srcModVertWeight = modVertWeights[i];
optModVertWeight.Bake(srcModVertWeight);
_vertWeights[i] = optModVertWeight;
}
_meshColor = Color.gray;
_isVisible = true;
}
/// <summary>
/// Modifier들의 계산 값들을 초기화한다.
/// </summary>
public void InitModifierCalculatedValues()
{
for (int iMod = 0; iMod < _modifiers.Count; iMod++)
{
//Modifier ->..
apModifierBase modifier = _modifiers[iMod];
List <apModifierParamSetGroup> paramSetGroups = modifier._paramSetGroup_controller;
for (int iGroup = 0; iGroup < paramSetGroups.Count; iGroup++)
{
//Modifier -> ParamSetGroup ->..
apModifierParamSetGroup paramSetGroup = paramSetGroups[iGroup];
List <apModifierParamSet> paramSets = paramSetGroup._paramSetList;
for (int iParam = 0; iParam < paramSets.Count; iParam++)
{
//Modifier -> ParamSetGroup -> ParamSet ->...
apModifierParamSet paramSet = paramSets[iParam];
List <apModifiedMesh> modMeshes = paramSet._meshData;
List <apModifiedBone> modBones = paramSet._boneData;
for (int iModMesh = 0; iModMesh < modMeshes.Count; iModMesh++)
{
apModifiedMesh modMesh = modMeshes[iModMesh];
if (modMesh._vertices != null && modMesh._vertices.Count > 0)
{
//ModVert 초기화 => 현재는 초기화 할게 없다.
}
if (modMesh._vertRigs != null && modMesh._vertRigs.Count > 0)
{
//ModVertRig 초기화 => 현재는 초기화 할게 없다.
}
if (modMesh._vertWeights != null && modMesh._vertWeights.Count > 0)
{
apModifiedVertexWeight vertWeight = null;
for (int iVW = 0; iVW < modMesh._vertWeights.Count; iVW++)
{
vertWeight = modMesh._vertWeights[iVW];
vertWeight.InitCalculatedValue(); //<<초기화를 하자. (여기서는 물리값)
}
}
}
for (int iModBone = 0; iModBone < modBones.Count; iModBone++)
{
apModifiedBone modBone = modBones[iModBone];
//ModBone도 현재는 초기화 할게 없다.
}
}
}
}
}
public LinkedVertex(apVertex vertex, int level)
{
_vertex = vertex;
_vertUniqueID = vertex._uniqueID;
_modVertWeight = null;
_deltaPosLocalLinkToTarget = Vector2.zero;
_distLocal = 0.0f;
_distWeight = 0.0f;
_level = level;
}
/// <summary>
/// ModVertexWeight를 사용하는 Modifier 중 Physics인 경우,
/// Vertex의 Weight가 바뀌었다면 한번씩 이 함수를 호출해주자.
/// Constraint(자동), isEnabled(자동), Main(수동) 등을 다시 세팅한다.
/// </summary>
private void RefreshVertexWeight_Physics(bool isForceRefresh)
{
if (_transform_Mesh == null || _transform_Mesh._mesh == null || _vertWeights.Count == 0)
{
return;
}
bool isAnyChanged = false;
apModifiedVertexWeight vertWeight = null;
float bias = 0.001f;
for (int iVW = 0; iVW < _vertWeights.Count; iVW++)
{
vertWeight = _vertWeights[iVW];
bool isNextEnabled = false;
if (vertWeight._weight < bias)
{
isNextEnabled = false;
}
else
{
isNextEnabled = true;
}
//Weight 활성화 여부가 바뀌었는지 체크
if (isNextEnabled != vertWeight._isEnabled)
{
vertWeight._isEnabled = isNextEnabled;
isAnyChanged = true;
}
}
if (!isAnyChanged && !isForceRefresh)
{
return;
}
for (int iVW = 0; iVW < _vertWeights.Count; iVW++)
{
vertWeight = _vertWeights[iVW];
vertWeight.RefreshModMeshAndWeights(this);
}
for (int iVW = 0; iVW < _vertWeights.Count; iVW++)
{
vertWeight = _vertWeights[iVW];
vertWeight.RefreshLinkedVertex();
}
}
// Init - Bake
//--------------------------------------------
public void Bake(apPhysicsMeshParam srcPhysicParam, List <apModifiedVertexWeight> modVertWeights, apPortrait portrait)
{
_nVertWeights = modVertWeights.Count;
_vertWeights = new apOptModifiedPhysicsVertex[_nVertWeights];
_physicMeshParam = new apOptPhysicsMeshParam();
_physicMeshParam.Bake(srcPhysicParam);
_physicMeshParam.Link(portrait);
for (int i = 0; i < _nVertWeights; i++)
{
apOptModifiedPhysicsVertex optModPhysicVert = new apOptModifiedPhysicsVertex();
apModifiedVertexWeight srcModVertWeight = modVertWeights[i];
optModPhysicVert.Bake(srcModVertWeight);
_vertWeights[i] = optModPhysicVert;
}
}
// 단축키 : 버텍스 전체 선택
private void OnHotKeyEvent__Modifier_Physics__Ctrl_A(object paramObject)
{
if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
{
return;
}
if (Editor.Select.ModRenderVertListOfMod == null)
{
return;
}
if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None && Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
{
//선택된 RenderUnit을 고르자
apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);
if (targetRenderUnit != null)
{
//모든 버텍스를 선택
for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
{
apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
{
return(renderVert._vertex._uniqueID == a._vertexUniqueID);
});
Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
Editor.Gizmos.SetSelectResultForce_Multiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod);
Editor.RefreshControllerAndHierarchy(false);
//Editor.Repaint();
Editor.SetRepaint();
Editor.Select.AutoSelectModMeshOrModBone();
}
}
}
public void Bake(apModifiedVertexWeight srcModVertWeight)
{
_isEnabled = srcModVertWeight._isEnabled;
_weight = srcModVertWeight._weight;
_pos_World_NoMod = srcModVertWeight._pos_World_NoMod;
//PhysicsParam도 Bake
apPhysicsVertParam srcVertParam = srcModVertWeight._physicParam;
_isConstraint = srcVertParam._isConstraint;
_isMain = srcVertParam._isMain;
_linkedVertices.Clear();
for (int i = 0; i < srcVertParam._linkedVertices.Count; i++)
{
apPhysicsVertParam.LinkedVertex srcLinkedVert = srcVertParam._linkedVertices[i];
_linkedVertices.Add(new LinkedVertex(srcLinkedVert)); //<<Add + Bake
}
_viscosityGroupID = srcVertParam._viscosityGroupID;
}
public void RefreshVertexWeights(apPortrait portrait, bool isPhysics, bool isVolume)
{
if (_renderUnit != null)
{
//"Modifier가 연산되기 전"의 WorldPosition을 미리 계산하자
_renderUnit.CalculateWorldPositionWithoutModifier();
}
//Debug.Log("<<< RefreshVertexWeights >>>");
if (_transform_Mesh._mesh != null)
{
bool isSameVerts = true;
if (_vertWeights.Count == 0 || _vertWeights.Count != _transform_Mesh._mesh._vertexData.Count)
{
isSameVerts = false;
}
else
{
//전부 비교해볼까나..
//빠르게 단순 링크를 시도해보고, 한번이라도 실패하면 다시 리스트를 만들어야한다.
List <apVertex> meshVertList = _transform_Mesh._mesh._vertexData;
apVertex meshVert = null;
apModifiedVertexWeight modVertWeight = null;
for (int i = 0; i < meshVertList.Count; i++)
{
meshVert = meshVertList[i];
modVertWeight = _vertWeights[i];
if (modVertWeight._vertexUniqueID != meshVert._uniqueID)
{
//버텍스 리스트 갱신이 필요하다
isSameVerts = false;
break;
}
modVertWeight.Link(this, _transform_Mesh._mesh, meshVert);
}
}
if (!isSameVerts)
{
//유효한 Vertex만 찾아서 넣어준다.
//유효하면 - Link
//유효하지 않다면 - Pass (Link 안된거 삭제)
//없는건 - Add
//순서는.. Index를 넣어서
//1. 일단 기존 데이터 복사 - 없어진 Vertex를 빼자
if (_vertWeights.Count != 0)
{
apModifiedVertexWeight modVertWeight = null;
for (int i = 0; i < _vertWeights.Count; i++)
{
modVertWeight = _vertWeights[i];
apVertex existVert = _transform_Mesh._mesh._vertexData.Find(delegate(apVertex a)
{
return(a._uniqueID == modVertWeight._vertexUniqueID);
});
if (existVert != null)
{
//유효하다면 Link
modVertWeight.Link(this, _transform_Mesh._mesh, existVert);
}
else
{
//유효하지 않다면.. Unlink -> 나중에 삭제됨
modVertWeight._vertex = null;
}
}
//이제 존재하지 않는 Vertex에 대해서는 삭제
_vertWeights.RemoveAll(delegate(apModifiedVertexWeight a)
{
return(a._vertex == null);
});
List <apVertex> meshVertList = _transform_Mesh._mesh._vertexData;
apVertex meshVert = null;
for (int i = 0; i < meshVertList.Count; i++)
{
meshVert = meshVertList[i];
//해당 Vertex가 있었는가
bool isLinked = _vertWeights.Exists(delegate(apModifiedVertexWeight a)
{
return(a._vertex == meshVert);
});
//없으면 추가
if (!isLinked)
{
apModifiedVertexWeight newVertWeight = new apModifiedVertexWeight();
newVertWeight.Init(meshVert._uniqueID, meshVert);
newVertWeight.SetDataType(isPhysics, isVolume); //<<어떤 타입인지 넣는다.
//TODO:Modifier에 따라 특성 추가
newVertWeight.Link(this, _transform_Mesh._mesh, meshVert);
_vertWeights.Add(newVertWeight); //<<새로 추가할 리스트에 넣어준다.
}
}
//Vertex Index에 맞게 정렬
_vertWeights.Sort(delegate(apModifiedVertexWeight a, apModifiedVertexWeight b)
{
return(a._vertIndex - b._vertIndex);
});
}
else
{
//2. 아예 리스트가 없을 때
_vertWeights.Clear();
List <apVertex> meshVertList = _transform_Mesh._mesh._vertexData;
apVertex meshVert = null;
for (int i = 0; i < meshVertList.Count; i++)
{
meshVert = meshVertList[i];
apModifiedVertexWeight newVertWeight = new apModifiedVertexWeight();
newVertWeight.Init(meshVert._uniqueID, meshVert);
newVertWeight.SetDataType(isPhysics, isVolume); //<<어떤 타입인지 넣는다.
//TODO:Modifier에 따라 특성 추가
newVertWeight.Link(this, _transform_Mesh._mesh, meshVert);
_vertWeights.Add(newVertWeight); //<<새로 추가할 리스트에 넣어준다.
}
}
}
for (int i = 0; i < _vertWeights.Count; i++)
{
_vertWeights[i].RefreshModMeshAndWeights(this);
}
}
//물리 관련 Refresh를 한번 더 한다.
if (isPhysics)
{
RefreshVertexWeight_Physics(true);
}
}
/// <summary>
/// Physic Modifier내에서의 Gizmo 이벤트 : Vertex 계열 선택시 [단일 선택]
/// </summary>
/// <param name="mousePosGL"></param>
/// <param name="mousePosW"></param>
/// <param name="btnIndex"></param>
/// <param name="selectType"></param>
/// <returns></returns>
public apGizmos.SelectResult Select__Modifier_Physics(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
{
return(null);
}
//(Editing 상태일 때)
//1. Vertex 선택
//2. (Lock 걸리지 않았다면) 다른 Transform을 선택
//(Editing 상태가 아닐 때)
//(Lock 걸리지 않았다면) Transform을 선택한다.
// Child 선택이 가능하면 MeshTransform을 선택. 그렇지 않아면 MeshGroupTransform을 선택해준다.
if (Editor.Select.ModRenderVertListOfMod == null)
{
return(null);
}
int prevSelectedCount = Editor.Select.ModRenderVertListOfMod.Count;
if (!Editor.Controller.IsMouseInGUI(mousePosGL))
{
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
bool isChildMeshTransformSelectable = Editor.Select.Modifier.IsTarget_ChildMeshTransform;
//apGizmos.SELECT_RESULT result = apGizmos.SELECT_RESULT.None;
bool isTransformSelectable = false;
if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None)
{
//(Editing 상태일 때)
//1. Vertex 선택
//2. (Lock 걸리지 않았다면) 다른 Transform을 선택
bool selectVertex = false;
if (Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
{
//일단 선택한 Vertex가 클릭 가능한지 체크
if (Editor.Select.ModRenderVertOfMod != null)
{
if (Editor.Select.ModRenderVertListOfMod.Count == 1)
{
if (Editor.Controller.IsVertexClickable(apGL.World2GL(Editor.Select.ModRenderVertOfMod._renderVert._pos_World), mousePosGL))
{
if (selectType == apGizmos.SELECT_TYPE.Subtract)
{
//삭제인 경우 : ModVertWeight를 선택한다.
Editor.Select.RemoveModVertexOfModifier(null, null, Editor.Select.ModRenderVertOfMod._modVertWeight, Editor.Select.ModRenderVertOfMod._renderVert);
}
else
{
//그 외에는 => 그대로 갑시다.
selectVertex = true;
//return apGizmos.SELECT_RESULT.SameSelected;
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
}
else
{
//여러개라고 하네요.
List <apSelection.ModRenderVert> modRenderVerts = Editor.Select.ModRenderVertListOfMod;
for (int iModRenderVert = 0; iModRenderVert < modRenderVerts.Count; iModRenderVert++)
{
apSelection.ModRenderVert modRenderVert = modRenderVerts[iModRenderVert];
if (Editor.Controller.IsVertexClickable(apGL.World2GL(modRenderVert._renderVert._pos_World), mousePosGL))
{
if (selectType == apGizmos.SELECT_TYPE.Subtract)
{
//삭제인 경우
//하나 지우고 끝
//결과는 List의 개수
Editor.Select.RemoveModVertexOfModifier(null, null, modRenderVert._modVertWeight, modRenderVert._renderVert);
}
else if (selectType == apGizmos.SELECT_TYPE.Add)
{
//Add 상태에서 원래 선택된걸 누른다면
//추가인 경우 => 그대로
selectVertex = true;
}
else
{
//만약... new 라면?
//다른건 초기화하고
//얘만 선택해야함
apRenderVertex selectedRenderVert = modRenderVert._renderVert;
apModifiedVertexWeight selectedModVertWeight = modRenderVert._modVertWeight;
Editor.Select.SetModVertexOfModifier(null, null, null, null);
Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, selectedRenderVert);
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
}
}
}
if (selectType == apGizmos.SELECT_TYPE.New)
{
//Add나 Subtract가 아닐땐, 잘못 클릭하면 선택을 해제하자 (전부)
Editor.Select.SetModVertexOfModifier(null, null, null, null);
}
if (selectType != apGizmos.SELECT_TYPE.Subtract)
{
if (Editor.Select.ExKey_ModMesh._transform_Mesh != null &&
Editor.Select.ExKey_ModMesh._vertices != null)
{
//선택된 RenderUnit을 고르자
apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);
if (targetRenderUnit != null)
{
for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
{
apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
bool isClick = Editor.Controller.IsVertexClickable(apGL.World2GL(renderVert._pos_World), mousePosGL);
if (isClick)
{
apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
{
return(renderVert._vertex._uniqueID == a._vertexUniqueID);
});
if (selectedModVertWeight != null)
{
if (selectType == apGizmos.SELECT_TYPE.New)
{
Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
else if (selectType == apGizmos.SELECT_TYPE.Add)
{
Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
selectVertex = true;
//result = apGizmos.SELECT_RESULT.NewSelected;
break;
}
}
}
}
}
}
}
//Vertex를 선택한게 없다면
//+ Lock 상태가 아니라면
if (!selectVertex && !Editor.Select.IsLockExEditKey)
{
//Transform을 선택
isTransformSelectable = true;
}
}
else
{
//(Editing 상태가 아닐때)
isTransformSelectable = true;
if (Editor.Select.ExKey_ModMesh != null && Editor.Select.IsLockExEditKey)
{
//뭔가 선택된 상태에서 Lock이 걸리면 다른건 선택 불가
isTransformSelectable = false;
}
}
if (isTransformSelectable && selectType == apGizmos.SELECT_TYPE.New)
{
//(Editing 상태가 아닐 때)
//Transform을 선택한다.
apTransform_Mesh selectedMeshTransform = null;
List <apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All; //<<정렬된 Render Unit
for (int iUnit = 0; iUnit < renderUnits.Count; iUnit++)
{
apRenderUnit renderUnit = renderUnits[iUnit];
if (renderUnit._meshTransform != null && renderUnit._meshTransform._mesh != null)
{
if (renderUnit._meshTransform._isVisible_Default && renderUnit._meshColor2X.a > 0.1f) //Alpha 옵션 추가
{
//Debug.LogError("TODO : Mouse Picking 바꿀것");
bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
mousePosGL, renderUnit);
if (isPick)
{
selectedMeshTransform = renderUnit._meshTransform;
//찾았어도 계속 찾는다.
//뒤의 아이템이 "앞쪽"에 있는 것이기 때문
}
}
}
}
if (selectedMeshTransform != null)
{
//만약 ChildMeshGroup에 속한 거라면,
//Mesh Group 자체를 선택해야 한다. <- 추가 : Child Mesh Transform이 허용되는 경우 그럴 필요가 없다.
apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup || isChildMeshTransformSelectable)
{
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
}
else
{
apTransform_MeshGroup childMeshGroupTransform = Editor.Select.MeshGroup.FindChildMeshGroupTransform(parentMeshGroup);
if (childMeshGroupTransform != null)
{
Editor.Select.SetSubMeshGroupInGroup(childMeshGroupTransform);
}
else
{
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
}
}
}
else
{
Editor.Select.SetSubMeshInGroup(null);
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
//개수에 따라 한번더 결과 보정
if (Editor.Select.ModRenderVertListOfMod != null)
{
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
return(null);
}
/// <summary>
/// Physics Modifier내에서의 Gizmo 이벤트 : Vertex 계열 선택시 [복수 선택]
/// </summary>
/// <param name="mousePosGL_Min"></param>
/// <param name="mousePosGL_Max"></param>
/// <param name="mousePosW_Min"></param>
/// <param name="mousePosW_Max"></param>
/// <param name="areaSelectType"></param>
/// <returns></returns>
public apGizmos.SelectResult MultipleSelect__Modifier_Physics(Vector2 mousePosGL_Min, Vector2 mousePosGL_Max, Vector2 mousePosW_Min, Vector2 mousePosW_Max, apGizmos.SELECT_TYPE areaSelectType)
{
if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
{
return(null);
}
if (Editor.Select.ModRenderVertListOfMod == null)
{
return(null);
}
// 이건 다중 버텍스 선택밖에 없다.
//Transform 선택은 없음
bool isAnyChanged = false;
if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None && Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
{
//선택된 RenderUnit을 고르자
apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);
if (targetRenderUnit != null)
{
for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
{
apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
bool isSelectable = (mousePosW_Min.x < renderVert._pos_World.x && renderVert._pos_World.x < mousePosW_Max.x) &&
(mousePosW_Min.y < renderVert._pos_World.y && renderVert._pos_World.y < mousePosW_Max.y);
if (isSelectable)
{
apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
{
return(renderVert._vertex._uniqueID == a._vertexUniqueID);
});
if (selectedModVertWeight != null)
{
if (areaSelectType == apGizmos.SELECT_TYPE.Add ||
areaSelectType == apGizmos.SELECT_TYPE.New)
{
Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
else
{
Editor.Select.RemoveModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
isAnyChanged = true;
}
}
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
}
if (isAnyChanged)
{
Editor.Select.AutoSelectModMeshOrModBone();
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
/// <summary>
/// Linked Vertex의 객체를 Link한다.
/// </summary>
/// <param name="parentModMesh"></param>
public void Link(apModifiedMesh parentModMesh, apModifiedVertexWeight parentModVertWeight)
{
_parentModMesh = parentModMesh;
_parentModVertWeight = parentModVertWeight;
if (_linkedVertices == null)
{
_linkedVertices = new List <LinkedVertex>();
}
if (parentModMesh._transform_Mesh == null || parentModMesh._transform_Mesh._mesh == null)
{
Debug.LogError("Physics Param Link Error : MeshTransform is Null of Mesh is Null");
return;
}
//????
//이게 왜 Link에 있지??
//이거 많이 느림
//데이터 저장 후 ID를 통해서 바로 Link해야하는데 매번 조회 후 생성+연결하려고 함.
//이 부분을 고쳐서 Physic.LinkedVertex를 미리 생성하고 여기서는 바로 연결해야한다. 로딩 느릴수밖에 없네..
//TODO
//...대체 방법이 없는데요..
apMesh mesh = parentModMesh._transform_Mesh._mesh;
//int maxVertLevel = 3;
int maxVertLevel = 1;
//연결된 apVertex를 받아오자 (최대 3레벨)
//수정 > 1레벨로도 충분할 듯
List <apMesh.LinkedVertexResult> linkedVerticesOnMesh = mesh.GetLinkedVertex(_parentModVertWeight._vertex, maxVertLevel);
//두개의 리스트를 비교하여
//- 같으면 단순 Link
//- 없으면 추가해서 Link
//- 연결되지 않았으면 제외
//+Contraint 체크를 위해서, 1-Level 을 따로 분류 (또는 Level 값을 넣자)
//1. 추가할 것을 체크하자
apMesh.LinkedVertexResult srcVert = null;
apModifiedVertexWeight modVertWeight = null;
for (int iSrcVert = 0; iSrcVert < linkedVerticesOnMesh.Count; iSrcVert++)
{
srcVert = linkedVerticesOnMesh[iSrcVert];
modVertWeight = _parentModMesh.GetVertexWeight(srcVert._vertex);
LinkedVertex linkedVert = _linkedVertices.Find(delegate(LinkedVertex a)
{
return(a._vertUniqueID == srcVert._vertex._uniqueID);
});
if (linkedVert == null)
{
//새로 추가해야하는 Linked Vert
LinkedVertex newLinkedVert = new LinkedVertex(srcVert._vertex, srcVert._level);
newLinkedVert.Link(srcVert._vertex, modVertWeight);
_linkedVertices.Add(newLinkedVert);
}
else
{
//이미 추가되었으니 Link만 하자
linkedVert.Link(srcVert._vertex, modVertWeight);
}
}
//2. 이제 제거할 것을 체크하자
//연결 안된건 지우자
_linkedVertices.RemoveAll(delegate(LinkedVertex a)
{
if (a._vertex == null || a._modVertWeight == null)
{
return(true);
}
if (!linkedVerticesOnMesh.Exists(delegate(apMesh.LinkedVertexResult b)
{
return(b._vertex == a._vertex);
}))
{
//연결된게 아니다. 찾을 수 없다.
return(true);
}
return(false);
});
//전체 길이를 체크하여 역 Weight를 걸자
RefreshLinkedVertex();
}
public void Link(apVertex linkedVertex, apModifiedVertexWeight linkedModVertWeight)
{
_vertex = linkedVertex;
_modVertWeight = linkedModVertWeight;
}
