public void Bake(apPortrait portrait, apOptModifierUnitBase parentModifier, apModifierParamSetGroup srcParamSetGroup)
{
_portrait = portrait;
_parentModifier = parentModifier;
_syncTarget = srcParamSetGroup._syncTarget;
//_keyControlParamName = srcParamSetGroup._keyControlParamName;
_keyControlParamID = srcParamSetGroup._keyControlParamID;
_keyControlParam = null; //<<이건 링크로 해결하자
//애니메이션 값도 넣어주자
_keyAnimClipID = srcParamSetGroup._keyAnimClipID;
_keyAnimTimelineID = srcParamSetGroup._keyAnimTimelineID;
_keyAnimTimelineLayerID = srcParamSetGroup._keyAnimTimelineLayerID;
_keyAnimClip = null;
_keyAnimTimeline = null;
_keyAnimTimelineLayer = null;
_paramSetList.Clear();
for (int i = 0; i < srcParamSetGroup._paramSetList.Count; i++)
{
apModifierParamSet srcParamSet = srcParamSetGroup._paramSetList[i];
apOptParamSet optParamSet = new apOptParamSet();
optParamSet.LinkParamSetGroup(this, portrait);
optParamSet.BakeModifierParamSet(srcParamSet, portrait);
_paramSetList.Add(optParamSet);
}
_isEnabled = srcParamSetGroup._isEnabled;
_layerIndex = srcParamSetGroup._layerIndex;
_layerWeight = srcParamSetGroup._layerWeight;
_blendMethod = srcParamSetGroup._blendMethod;
_isColorPropertyEnabled = srcParamSetGroup._isColorPropertyEnabled; //<<추가.
_calculatedWeightedVertexList.Clear();
for (int i = 0; i < srcParamSetGroup._calculatedWeightedVertexList.Count; i++)
{
apModifierParamSetGroupVertWeight srcWV = srcParamSetGroup._calculatedWeightedVertexList[i];
apOptParamSetGroupVertWeight optWV = new apOptParamSetGroupVertWeight();
optWV.Bake(srcWV);
optWV.Link(portrait.GetOptTransform(optWV._meshTransform_ID)); //OptTransform을 연결한다.
_calculatedWeightedVertexList.Add(optWV);
}
LinkPortrait(portrait, parentModifier);
}
public void Bake(apModifierParamSetGroupVertWeight srcWeightedVert)
{
_vertWeightList.Clear();
for (int i = 0; i < srcWeightedVert._weightedVerts.Count; i++)
{
_vertWeightList.Add(Mathf.Clamp01(srcWeightedVert._weightedVerts[i]._adaptWeight));
}
_meshTransform_ID = srcWeightedVert._meshTransform_ID;
_optTransform = null;
}
// Init
//--------------------------------------------------
public apCalculatedResultParam(CALCULATED_VALUE_TYPE calculatedValueType,
CALCULATED_SPACE calculatedSpace,
apModifierBase linkedModifier,
apRenderUnit targetRenderUnit,
apRenderUnit ownerRenderUnit, //<<추가 10.2 : Modifier를 가지고 있었던 RenderUnit
apBone targetBone, //<<추가
apModifierParamSetGroupVertWeight weightedVertData)
{
_calculatedValueType = calculatedValueType;
_calculatedSpace = calculatedSpace;
_linkedModifier = linkedModifier;
_targetRenderUnit = targetRenderUnit;
_ownerRenderUnit = ownerRenderUnit;
_targetBone = targetBone; //<추가
_weightedVertexData = weightedVertData;
//처리 타입이 Vertex 계열이면 Vertex List를 준비해야한다.
if ((int)(_calculatedValueType & CALCULATED_VALUE_TYPE.VertexPos) != 0)
{
int nPos = 0;
if (_targetRenderUnit._meshTransform != null && _targetRenderUnit._meshTransform._mesh != null)
{
nPos = _targetRenderUnit._meshTransform._mesh._vertexData.Count;
}
_result_Positions = new Vector2[nPos];
//_tmp_Positions = new List<Vector2>();
for (int i = 0; i < nPos; i++)
{
_result_Positions[i] = Vector2.zero;
//_tmp_Positions.Add(Vector2.zero);
}
//추가 : 만약 리깅타입이면 Vertex 개수만큼의 Matrix를 만들어야 한다.
if (_linkedModifier.ModifierType == apModifierBase.MODIFIER_TYPE.Rigging)
{
_result_VertMatrices = new apMatrix3x3[nPos];
for (int i = 0; i < nPos; i++)
{
_result_VertMatrices[i] = apMatrix3x3.zero;
}
}
}
_debugID = UnityEngine.Random.Range(0, 10000);
}
//2) Layer_ParamSetGroup
public void CalculateParamSetGroup(float layerWeight,
int iLayer,
apModifierParamSetGroup.BLEND_METHOD blendType,
apModifierParamSetGroupVertWeight paramSetGroupVertWeight,
apCalculatedLog calPraramResultLog
)
{
_weight = layerWeight;
_paramSetGroupLayerIndex = iLayer;
switch (blendType)
{
case apModifierParamSetGroup.BLEND_METHOD.Additive:
_layerBlendType = BLEND_METHOD.Additive;
break;
case apModifierParamSetGroup.BLEND_METHOD.Interpolation:
_layerBlendType = BLEND_METHOD.Interpolation;
break;
}
//_paramSetGroupBlendType = blendType;
_paramSetGroupVertWeight = paramSetGroupVertWeight; //<<보통은 Null
LinkLog_ModLayerParent(calPraramResultLog);
}
// Init
//--------------------------------------------------
public apCalculatedResultParam(CALCULATED_VALUE_TYPE calculatedValueType,
CALCULATED_SPACE calculatedSpace,
apModifierBase linkedModifier,
apRenderUnit targetRenderUnit,
apBone targetBone, //<<추가
apModifierParamSetGroupVertWeight weightedVertData)
{
_calculatedValueType = calculatedValueType;
_calculatedSpace = calculatedSpace;
_linkedModifier = linkedModifier;
_targetRenderUnit = targetRenderUnit;
_targetBone = targetBone; //<추가
_weightedVertexData = weightedVertData;
//처리 타입이 Vertex 계열이면 Vertex List를 준비해야한다.
if ((int)(_calculatedValueType & CALCULATED_VALUE_TYPE.VertexPos) != 0)
{
int nPos = 0;
if (_targetRenderUnit._meshTransform != null && _targetRenderUnit._meshTransform._mesh != null)
{
nPos = _targetRenderUnit._meshTransform._mesh._vertexData.Count;
}
_result_Positions = new List <Vector2>();
//_tmp_Positions = new List<Vector2>();
for (int i = 0; i < nPos; i++)
{
_result_Positions.Add(Vector2.zero);
//_tmp_Positions.Add(Vector2.zero);
}
}
_debugID = UnityEngine.Random.Range(0, 10000);
}
public bool RefreshSync()
{
if (_syncTransform_Mesh == null)
{
_syncTransform_Mesh = new List <apTransform_Mesh>();
}
_syncTransform_Mesh.Clear();
if (_syncTransform_MeshGroup == null)
{
_syncTransform_MeshGroup = new List <apTransform_MeshGroup>();
}
_syncTransform_MeshGroup.Clear();
if (_syncBone == null)
{
_syncBone = new List <apBone>();
}
_syncBone.Clear();
//한번이라도 등장한 MeshTransform / MeshGroup Transform을 찾자
for (int i = 0; i < _paramSetList.Count; i++)
{
apModifierParamSet paramSet = _paramSetList[i];
for (int iModMesh = 0; iModMesh < paramSet._meshData.Count; iModMesh++)
{
apModifiedMesh modMesh = paramSet._meshData[iModMesh];
if (modMesh._transform_Mesh != null)
{
//수정 4.1 : Mesh가 없는 MeshTransform
if (modMesh._transform_Mesh._mesh == null)
{
//Debug.Log("AnyPortrait : Mesh of [" + modMesh._transform_Mesh._nickName + "] is removed. Please check it.");
}
else
{
if (!_syncTransform_Mesh.Contains(modMesh._transform_Mesh))
{
_syncTransform_Mesh.Add(modMesh._transform_Mesh);
}
}
//이전 코드
//if (!_syncTransform_Mesh.Contains(modMesh._transform_Mesh))
//{
// _syncTransform_Mesh.Add(modMesh._transform_Mesh);
//}
}
if (modMesh._transform_MeshGroup != null)
{
if (!_syncTransform_MeshGroup.Contains(modMesh._transform_MeshGroup))
{
_syncTransform_MeshGroup.Add(modMesh._transform_MeshGroup);
}
}
}
for (int iModBone = 0; iModBone < paramSet._boneData.Count; iModBone++)
{
apModifiedBone modBone = paramSet._boneData[iModBone];
if (modBone._bone != null)
{
//>> 이건 Bone Set이 필요없다.
if (modBone._meshGroup_Bone != null &&
modBone._meshGroup_Bone._boneList_All.Contains(modBone._bone) //해당 MeshGroup에 Bone이 존재하는가.
)
{
if (!_syncBone.Contains(modBone._bone))
{
_syncBone.Add(modBone._bone);
}
}
else
{
//Modifier로 등록되었지만 Bone이 삭제되었다면 여기로 들어온다.
//Sync가 안됨
}
}
}
}
//동기화 전용 Sync Transform을 모든 ParamSet에 넣자
bool isAnyChanged = false;
for (int iSync = 0; iSync < _syncTransform_Mesh.Count; iSync++)
{
apTransform_Mesh meshTransform = _syncTransform_Mesh[iSync];
//bool isAdd = _parentModifier.AddMeshTransformToAllParamSet(_parentModifier._meshGroup, meshTransform, false);
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
bool isAdd = AddMeshTransformToParamSet(_paramSetList[iParamSet], meshTransform);
if (isAdd)
{
isAnyChanged = true;
}
}
}
for (int iSync = 0; iSync < _syncTransform_MeshGroup.Count; iSync++)
{
apTransform_MeshGroup meshGroupTransform = _syncTransform_MeshGroup[iSync];
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
bool isAdd = AddMeshGroupTransformToParamSet(_paramSetList[iParamSet], meshGroupTransform);
//bool isAdd = _parentModifier.AddMeshGroupTransformToAllParamSet(_parentModifier._meshGroup, meshGroupTransform, false);
if (isAdd)
{
isAnyChanged = true;
}
}
}
for (int iSync = 0; iSync < _syncBone.Count; iSync++)
{
apBone bone = _syncBone[iSync];
apTransform_MeshGroup meshGroupTransform = null;
if (_parentModifier._meshGroup == bone._meshGroup)
{
meshGroupTransform = _parentModifier._meshGroup._rootMeshGroupTransform;
}
else
{
meshGroupTransform = _parentModifier._meshGroup.FindChildMeshGroupTransform(bone._meshGroup);
}
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
//이전
//bool isAdd = AddBoneToParamSet(_paramSetList[iParamSet], bone._meshGroup._rootMeshGroupTransform, bone);
//변경 : ChildMeshGroup의 Root MGTF로 설정하는 코드는 잘못되었다.
bool isAdd = AddBoneToParamSet(_paramSetList[iParamSet], meshGroupTransform, bone);
if (isAdd)
{
isAnyChanged = true;
}
}
}
//추가 : Sync시 WeightedVertex도 같이 처리해주자
// 동기화 안된건 자동 삭제
for (int i = 0; i < _calculatedWeightedVertexList.Count; i++)
{
_calculatedWeightedVertexList[i]._isSync = false;
}
for (int iSync = 0; iSync < _syncTransform_Mesh.Count; iSync++)
{
apTransform_Mesh meshTransform = _syncTransform_Mesh[iSync];
apModifierParamSetGroupVertWeight existWV = _calculatedWeightedVertexList.Find(delegate(apModifierParamSetGroupVertWeight a)
{
return(a._meshTransform_ID == meshTransform._transformUniqueID);
});
if (existWV != null)
{
existWV._isSync = true;
existWV.LinkMeshTransform(meshTransform);
}
else
{
//없다. 새로 만들자
apModifierParamSetGroupVertWeight newVW = new apModifierParamSetGroupVertWeight(meshTransform);
newVW._isSync = true;
_calculatedWeightedVertexList.Add(newVW);
}
}
//동기화 되지 않은건 지운다.
_calculatedWeightedVertexList.RemoveAll(delegate(apModifierParamSetGroupVertWeight a)
{
return(!a._isSync);
});
return(isAnyChanged);
}
public void LinkWeightedVertexData(apModifierParamSetGroupVertWeight weightedVertData)
{
_weightedVertexData = weightedVertData;
}
public void LinkModifierStackToRenderUnitCalculateStack(bool isRoot = true, apMeshGroup rootMeshGroup = null)
{
//전체 Modifier중에서 RenderUnit을 포함한 Modifer를 찾는다.
//그 중, RenderUnit에 대한것만 처리할 CalculateResultParam을 만들고 연동한다.
//ResultParam을 RenderUnit의 CalculateStack에 넣는다.
//Debug.Log("--------------------------------------------------------------");
//Debug.Log("LinkModifierStackToRenderUnitCalculateStack [" + _parentMeshGroup._name + "]");
//Debug.Log("--------------------------------------------------------------");
//수정
//각 ModMesh에서 계층적인 Link를 할 수 있도록
//RenderUnit을 매번 바꾸어주자
if (isRoot)
{
rootMeshGroup = _parentMeshGroup;
//Modifier-ParamSetGroup-ParamSet + ModMesh가 "실제 RenderUnit"과 링크되지 않으므로
//Calculate Param을 만들기 전에 이 링크를 먼저 해주어야 한다.
}
//Modifier를 돌면서 ParamSet 데이터를 Calculated 데이터로 변환해서 옮긴다.
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;
//1. Mod Mesh => Calculate Param으로 연결한다.
for (int iModMesh = 0; iModMesh < modMeshes.Count; iModMesh++)
{
//[핵심]
//Modifier -> ParamSetGroup -> ParamSet -> ModMeh
//이제 이 ModMesh와 타겟 Transform을 연결하자.
//연결할땐 Calculated 오브젝트를 만들어서 연결
apModifiedMesh modMesh = modMeshes[iModMesh];
#region [미사용 코드]
//여기서 수정
//Root가 아닐때 > RenderUnit을 자체적으로 세팅할게 아니라, Root MeshGroup을 기준으로 RenderUnit을 찾자
//if(!isRoot)
//{
// apRenderUnit recursiveRenderUnit = null;
// if(modMesh._isMeshTransform)
// {
// recursiveRenderUnit = rootMeshGroup.GetRenderUnit(modMesh._transform_Mesh);
// }
// else
// {
// recursiveRenderUnit = rootMeshGroup.GetRenderUnit(modMesh._transform_MeshGroup);
// }
// if(recursiveRenderUnit != null)
// {
// //Debug.Log("Link ModStack -> Child Render Unit Changed [Modifier : " + modifier.DisplayName + "] / RenderUnit Name : " + recursiveRenderUnit.Name + " / is Changed : " + (modMesh._renderUnit != recursiveRenderUnit));
// //if(modMesh._renderUnit == null)
// //{
// // Debug.LogError("기존 RenderUnit이 Null이다.");
// //}
// //else if(modMesh._renderUnit._meshGroup == null)
// //{
// // Debug.LogError("기존 RenderUnit의 MeshGroup이 Null이다.");
// //}
// //else
// //{
// // Debug.Log("[" + modMesh._renderUnit._meshGroup._name + " > " + rootMeshGroup._name + "]");
// //}
// modMesh._renderUnit = recursiveRenderUnit;
// }
// else
// {
// Debug.LogError("Re Link Failed");
// }
//}
#endregion
if (modMesh._renderUnit == null)
{
continue;
}
//이미 만든 Calculate Param이 있는지 확인
apCalculatedResultParam existParam = modifier.GetCalculatedResultParam(modMesh._renderUnit);
//추가 : 만약 Calculated Param을 찾지 못했다면..
//Parent의 누군가가 이미 만들었을 수 있다!
//Root Parent MeshGroup에 요청해서 한번 더 확인하자
//(Calculated Result Param을 공유할 수 있기 때문)
if (existParam == null && rootMeshGroup != null)
{
//rootMeshGroup._modifierStack
//?? 이거 해야하나
}
apModifierParamSetGroupVertWeight weightedVertexData = null;
if (modMesh._transform_Mesh != null)
{
weightedVertexData = paramSetGroup.GetWeightVertexData(modMesh._transform_Mesh);
}
if (existParam != null)
{
//Debug.Log("> ModMesh [" + iModMesh + "] : " + modMesh._transformUniqueID + "< Add >");
existParam.AddParamSetAndModifiedValue(paramSetGroup, paramSet, modMesh, null);
existParam.LinkWeightedVertexData(weightedVertexData);
//if(!isRoot)
//{
// Debug.LogWarning("Child Modifier의 CalculateParam을 찾아서 적용 : "
// + modifier.DisplayName + " / " + existParam._debugID + " / " + existParam._targetRenderUnit.Name);
//}
}
else
{
//Debug.Log("> ModMesh [" + iModMesh + "] : " + modMesh._transformUniqueID + "< New >");
//새로 Calculate Param을 만들고..
apCalculatedResultParam newCalParam = new apCalculatedResultParam(
modifier.CalculatedValueType,
modifier.CalculatedSpace,
modifier,
modMesh._renderUnit,
null, //<Bone은 없으닝께..
weightedVertexData
);
newCalParam.AddParamSetAndModifiedValue(paramSetGroup, paramSet, modMesh, null);
// Modifier에 등록하고
modifier._calculatedResultParams.Add(newCalParam);
//RenderUnit에도 등록을 하자
modMesh._renderUnit._calculatedStack.AddCalculatedResultParam(newCalParam);
//if(!isRoot)
//{
// Debug.LogWarning("Child Modifier의 CalculateParam을 찾아서 적용 : "
// + modifier.DisplayName + " / " + newCalParam._debugID + " / " + newCalParam._targetRenderUnit.Name);
//}
}
//else
//{
// Debug.LogError("Link Modifier Stack Error : No Render Unit (isRoot : " + isRoot + ")");
//}
}
//2. Mod Bone => Calculate Param으로 연결한다.
for (int iModBone = 0; iModBone < modBones.Count; iModBone++)
{
apModifiedBone modBone = modBones[iModBone];
if (modBone._bone == null || modBone._renderUnit == null)
{
Debug.LogError("ModBone -> Calculate Link 실패 : [Bone : " + (modBone._bone != null) + ", RenderUnit : " + (modBone._renderUnit != null) + "]");
continue;
}
//이미 만든 Calculate Param이 있는지 확인
apCalculatedResultParam existParam = modifier.GetCalculatedResultParam_Bone(modBone._renderUnit, modBone._bone);
if (existParam != null)
{
//이미 있다면 ModBone만 추가해주자
existParam.AddParamSetAndModifiedValue(paramSetGroup, paramSet, null, modBone);
}
else
{
//Debug.Log("Mod Bone -> Calculate Param 등록");
//새로 CalculateParam을 만들고
apCalculatedResultParam newCalParam = new apCalculatedResultParam(
modifier.CalculatedValueType,
modifier.CalculatedSpace,
modifier,
modBone._renderUnit,
modBone._bone,
null //WeightedVertex
);
newCalParam.AddParamSetAndModifiedValue(paramSetGroup, paramSet, null, modBone);
// Modifier에 등록하고
modifier._calculatedResultParams.Add(newCalParam);
//RenderUnit에도 등록을 하자
modBone._renderUnit._calculatedStack.AddCalculatedResultParam(newCalParam);
}
}
}
}
//SubList를 한번 정렬하자
for (int iCal = 0; iCal < modifier._calculatedResultParams.Count; iCal++)
{
modifier._calculatedResultParams[iCal].SortSubList();
}
}
//추가>>
//하위 객체에 대해서도 Link를 자동으로 수행한다.
//다 끝나고 Sort
List <apTransform_MeshGroup> childMeshGroupTransforms = _parentMeshGroup._childMeshGroupTransforms;
apTransform_MeshGroup childMeshGroup = null;
if (childMeshGroupTransforms != null && childMeshGroupTransforms.Count > 0)
{
for (int i = 0; i < childMeshGroupTransforms.Count; i++)
{
childMeshGroup = childMeshGroupTransforms[i];
if (childMeshGroup._meshGroup != null && childMeshGroup._meshGroup != _parentMeshGroup)
{
childMeshGroup._meshGroup._modifierStack.LinkModifierStackToRenderUnitCalculateStack(false, rootMeshGroup); //<<여기서도 같이 수행
}
}
}
if (isRoot)
{
//Debug.Log("Start Sort : " + _parentMeshGroup._name);
//Root인 경우
//RenderUnit들을 검사하면서 Calculated Stack에 대해서 Sort를 해주자
List <apRenderUnit> renderUnits = _parentMeshGroup._renderUnits_All;
for (int i = 0; i < renderUnits.Count; i++)
{
renderUnits[i]._calculatedStack.Sort();
}
}
}
public bool RefreshSync()
{
if (_syncTransform_Mesh == null)
{
_syncTransform_Mesh = new List <apTransform_Mesh>();
}
_syncTransform_Mesh.Clear();
if (_syncTransform_MeshGroup == null)
{
_syncTransform_MeshGroup = new List <apTransform_MeshGroup>();
}
_syncTransform_MeshGroup.Clear();
if (_syncBone == null)
{
_syncBone = new List <apBone>();
}
_syncBone.Clear();
//한번이라도 등장한 MeshTransform / MeshGroup Transform을 찾자
for (int i = 0; i < _paramSetList.Count; i++)
{
apModifierParamSet paramSet = _paramSetList[i];
for (int iModMesh = 0; iModMesh < paramSet._meshData.Count; iModMesh++)
{
apModifiedMesh modMesh = paramSet._meshData[iModMesh];
if (modMesh._transform_Mesh != null)
{
if (!_syncTransform_Mesh.Contains(modMesh._transform_Mesh))
{
_syncTransform_Mesh.Add(modMesh._transform_Mesh);
}
}
if (modMesh._transform_MeshGroup != null)
{
if (!_syncTransform_MeshGroup.Contains(modMesh._transform_MeshGroup))
{
_syncTransform_MeshGroup.Add(modMesh._transform_MeshGroup);
}
}
}
for (int iModBone = 0; iModBone < paramSet._boneData.Count; iModBone++)
{
apModifiedBone modBone = paramSet._boneData[iModBone];
if (modBone._bone != null)
{
if (modBone._meshGroup_Bone != null && modBone._meshGroup_Bone._boneList_All.Contains(modBone._bone))
{
if (!_syncBone.Contains(modBone._bone))
{
_syncBone.Add(modBone._bone);
}
}
else
{
//Modifier로 등록되었지만 Bone이 삭제되었다면 여기로 들어온다.
//Sync가 안됨
}
}
}
}
//동기화 전용 Sync Transform을 모든 ParamSet에 넣자
bool isAnyChanged = false;
for (int iSync = 0; iSync < _syncTransform_Mesh.Count; iSync++)
{
apTransform_Mesh meshTransform = _syncTransform_Mesh[iSync];
//bool isAdd = _parentModifier.AddMeshTransformToAllParamSet(_parentModifier._meshGroup, meshTransform, false);
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
bool isAdd = AddMeshTransformToParamSet(_paramSetList[iParamSet], meshTransform);
if (isAdd)
{
isAnyChanged = true;
}
}
}
for (int iSync = 0; iSync < _syncTransform_MeshGroup.Count; iSync++)
{
apTransform_MeshGroup meshGroupTransform = _syncTransform_MeshGroup[iSync];
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
bool isAdd = AddMeshGroupTransformToParamSet(_paramSetList[iParamSet], meshGroupTransform);
//bool isAdd = _parentModifier.AddMeshGroupTransformToAllParamSet(_parentModifier._meshGroup, meshGroupTransform, false);
if (isAdd)
{
isAnyChanged = true;
}
}
}
for (int iSync = 0; iSync < _syncBone.Count; iSync++)
{
apBone bone = _syncBone[iSync];
for (int iParamSet = 0; iParamSet < _paramSetList.Count; iParamSet++)
{
bool isAdd = AddBoneToParamSet(_paramSetList[iParamSet], bone._meshGroup._rootMeshGroupTransform, bone);
if (isAdd)
{
isAnyChanged = true;
}
}
}
//추가 : Sync시 WeightedVertex도 같이 처리해주자
// 동기화 안된건 자동 삭제
for (int i = 0; i < _calculatedWeightedVertexList.Count; i++)
{
_calculatedWeightedVertexList[i]._isSync = false;
}
for (int iSync = 0; iSync < _syncTransform_Mesh.Count; iSync++)
{
apTransform_Mesh meshTransform = _syncTransform_Mesh[iSync];
apModifierParamSetGroupVertWeight existWV = _calculatedWeightedVertexList.Find(delegate(apModifierParamSetGroupVertWeight a)
{
return(a._meshTransform_ID == meshTransform._transformUniqueID);
});
if (existWV != null)
{
existWV._isSync = true;
existWV.LinkMeshTransform(meshTransform);
}
else
{
//없다. 새로 만들자
apModifierParamSetGroupVertWeight newVW = new apModifierParamSetGroupVertWeight(meshTransform);
newVW._isSync = true;
_calculatedWeightedVertexList.Add(newVW);
}
}
//동기화 되지 않은건 지운다.
_calculatedWeightedVertexList.RemoveAll(delegate(apModifierParamSetGroupVertWeight a)
{
return(!a._isSync);
});
return(isAnyChanged);
}
