// 실제로 연결된 데이터를 가져오자
//-------------------------------------------------------------------------------
/// <summary>
/// Animated Modifier 타입의 타임라인인 경우에, layer와 keyframe을 선택한 경우,
/// 해당 데이터와 연동된 paramSet을 가져온다. (paramSet에는 ModMesh가 포함되어있다)
/// </summary>
/// <param name="targetLayer"></param>
/// <param name="keyframe"></param>
/// <returns></returns>
public apModifierParamSet GetModifierParamSet(apAnimTimelineLayer targetLayer, apAnimKeyframe keyframe)
{
if (_linkType != apAnimClip.LINK_TYPE.AnimatedModifier ||
_linkedModifier == null)
{
return(null);
}
if (targetLayer == null || !_layers.Contains(targetLayer) || keyframe == null)
{
return(null);
}
apModifierParamSetGroup selectedParamSetGroup = _linkedModifier._paramSetGroup_controller.Find(delegate(apModifierParamSetGroup a)
{
return(a._keyAnimTimelineLayer == targetLayer);
});
if (selectedParamSetGroup == null)
{
return(null);
}
return(selectedParamSetGroup._paramSetList.Find(delegate(apModifierParamSet a)
{
return a.SyncKeyframe == keyframe;
}));
}
public void AddParamSetGroup(apModifierParamSetGroup paramSetGroup)
{
if (!_paramSetGroups.Contains(paramSetGroup))
{
_paramSetGroups.Add(paramSetGroup);
}
}
public ParamKeyValueSet(apModifierParamSetGroup keyParamSetGroup, apModifierParamSet paramSet, apModifiedBone modifiedValue)
{
_keyParamSetGroup = keyParamSetGroup;
_paramSet = paramSet;
_modifiedMesh = null;
_modifiedBone = modifiedValue;
_layerIndx = _paramSet._parentParamSetGroup._layerIndex;
}
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);
}
/// <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 ParamKeyValueSet(apModifierParamSetGroup keyParamSetGroup, apModifierParamSet paramSet, apModifiedBone modifiedValue)
{
_keyParamSetGroup = keyParamSetGroup;
_paramSet = paramSet;
_modifiedMesh = null;
_modifiedBone = modifiedValue;
_layerIndx = _paramSet._parentParamSetGroup._layerIndex;
//추가 : RotationBias
_isAnimRotationBias = false;
_animRotationBiasAngle = 0;
_animRotationBiasAngle_Prev = -1;
_animRotationBiasedMatrix = new apMatrix();
}
public void LinkParamSetGroup(apModifierParamSetGroup paramSetGroup)
{
_targetParamSetGroup = paramSetGroup;
}
public void SetParamSetGroup(apModifierParamSetGroup paramSetGroup)
{
_keyParamSetGroup = paramSetGroup;
//_controlParam = _keyParamSetGroup._keyControlParam;
}
public void LinkParamSetGroup(apModifierParamSetGroup paramSetGroup)
{
_parentParamSetGroup = paramSetGroup;
}
/// <summary>
/// ParamSet을 받아서 SubList와 연동한다.
/// </summary>
/// <param name="paramSet"></param>
/// <param name="modifiedValue"></param>
public void AddParamSetAndModifiedValue(apModifierParamSetGroup paramSetGroup,
apModifierParamSet paramSet,
apModifiedMesh modifiedMesh,
apModifiedBone modifiedBone)
{
ParamKeyValueSet existSet = GetParamKeyValue(paramSet);
if (existSet != null)
{
return;
}
//수정 : ModifiedBone을 넣어주자
//새로운 KeyValueSet을 만들어서 리스트에 추가하자
ParamKeyValueSet newKeyValueSet = null;
if (modifiedMesh != null)
{
//ModMesh를 등록하는 경우
newKeyValueSet = new ParamKeyValueSet(paramSetGroup, paramSet, modifiedMesh);
}
else if (modifiedBone != null)
{
//ModBone을 등록하는 경우
newKeyValueSet = new ParamKeyValueSet(paramSetGroup, paramSet, modifiedBone);
}
_paramKeyValues.Add(newKeyValueSet);
//Debug.LogError("Cur Param Key Value : " + _paramKeyValues.Count);
apCalculatedResultParamSubList targetSubList = null;
//같이 묶여서 작업할 SubList가 있는가
apCalculatedResultParamSubList existSubList = _subParamKeyValueList.Find(delegate(apCalculatedResultParamSubList a)
{
//return a._controlParam == paramSetGroup._keyControlParam;
return(a._keyParamSetGroup == paramSetGroup);
});
if (existSubList != null)
{
targetSubList = existSubList;
}
else
{
targetSubList = new apCalculatedResultParamSubList(this);
targetSubList.SetParamSetGroup(paramSetGroup);
//targetSubList.SetControlParam(paramSetGroup._keyControlParam);
_subParamKeyValueList.Add(targetSubList);
//Debug.LogError("AddParamSetAndModifiedMesh : Add New SubList");
}
#region [미사용 코드]
//switch (paramSetGroup._syncTarget)
//{
// case apModifierParamSetGroup.SYNC_TARGET.Controller:
// {
// if (paramSetGroup._keyControlParam != null)
// {
// //같이 묶여서 작업할 SubList가 있는가
// apCalculatedResultParamSubList existSubList = _subParamKeyValueList.Find(delegate (apCalculatedResultParamSubList a)
// {
// return a._controlParam == paramSetGroup._keyControlParam;
// });
// if (existSubList != null)
// {
// targetSubList = existSubList;
// }
// else
// {
// targetSubList = new apCalculatedResultParamSubList(this);
// targetSubList.SetParamSetGroup(paramSetGroup);
// //targetSubList.SetControlParam(paramSetGroup._keyControlParam);
// _subParamKeyValueList.Add(targetSubList);
// }
// }
// }
// break;
// case apModifierParamSetGroup.SYNC_TARGET.KeyFrame:
// {
// //...TODO
// Debug.LogError("TODO : KeyFrame 타입의 CalculateResultParam의 SubList 처리할 것");
// //??
// }
// break;
// case apModifierParamSetGroup.SYNC_TARGET.Static:
// {
// //Static은 1개만 있다.
// if(_subParamKeyValueList.Count == 0)
// {
// //새로 만들자.
// targetSubList = new apCalculatedResultParamSubList(this);
// targetSubList.SetStatic();
// _subParamKeyValueList.Add(targetSubList);
// }
// else
// {
// //있는거 사용하자
// targetSubList = _subParamKeyValueList[0];
// }
// }
// break;
//}
#endregion
//해당 SubList에 위에서 만든 KeyValueSet을 추가하자
if (targetSubList != null)
{
//ParamKeyValueSet을 추가하자
targetSubList.AddParamKeyValueSet(newKeyValueSet);
}
}
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();
}
}
}
/// <summary>
/// AnimTimeline을 선택하고, 그 안의 AnimTimeLayer를 모두 활성화한다.
/// 일반적으로 [선택하지 않은 AnimTimeline]들을 모두 해제하는 반면에,
/// 여기서는 해당 ParamSetGroup에 연동된 AnimTimeline이 AnimClip에 포함된다면 모두 포함시킨다.
/// </summary>
/// <param name="modifier"></param>
/// <param name="paramSetGroups"></param>
public void SetExclusiveModifierInEditing_MultipleParamSetGroup_General(apModifierBase modifier, apAnimClip targetAnimClip)
{
//apCalculatedResultParam.RESULT_TYPE targetResultType = modifier.CalculatedResultType;
//추가
//요청한 Modifier가 BoneTransform을 지원하는 경우
//Rigging은 비활성화 되어서는 안된다.
apModifierBase.MODIFIER_TYPE[] exGeneralTypes = modifier.GetGeneralExEditableModTypes();
if (exGeneralTypes == null)
{
exGeneralTypes = new apModifierBase.MODIFIER_TYPE[] { modifier.ModifierType };
}
for (int i = 0; i < _modifiers.Count; i++)
{
bool isValidType = false;
for (int iGT = 0; iGT < exGeneralTypes.Length; iGT++)
{
if (exGeneralTypes[iGT] == _modifiers[i].ModifierType)
{
isValidType = true;
break;
}
}
if (isValidType)
{
//AnimClip을 포함하는 ParamSetGroup에 한해서
_modifiers[i]._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.ExclusiveEnabled;
for (int iP = 0; iP < _modifiers[i]._paramSetGroup_controller.Count; iP++)
{
apModifierParamSetGroup paramSetGroup = _modifiers[i]._paramSetGroup_controller[iP];
if (paramSetGroup._keyAnimClip == targetAnimClip)
{
paramSetGroup._isEnabledExclusive = true;
}
else
{
paramSetGroup._isEnabledExclusive = false;
}
}
}
else
{
//지원하는 타입이 아니다.
//모두 Disabled한다.
_modifiers[i]._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.Disabled;
for (int iP = 0; iP < _modifiers[i]._paramSetGroup_controller.Count; iP++)
{
apModifierParamSetGroup paramSetGroup = _modifiers[i]._paramSetGroup_controller[iP];
paramSetGroup._isEnabledExclusive = false;
}
}
}
//Child MeshGroup에도 모두 적용하자
if (_parentMeshGroup != null)
{
if (_parentMeshGroup._childMeshGroupTransforms != null)
{
for (int i = 0; i < _parentMeshGroup._childMeshGroupTransforms.Count; i++)
{
apTransform_MeshGroup meshGroupTransform = _parentMeshGroup._childMeshGroupTransforms[i];
if (meshGroupTransform._meshGroup != null && meshGroupTransform._meshGroup != _parentMeshGroup)
{
meshGroupTransform._meshGroup._modifierStack.SetExclusiveModifierInEditing_MultipleParamSetGroup_General(modifier, targetAnimClip);
}
}
}
}
}
public void SetExclusiveModifierInEditing_MultipleParamSetGroup(apModifierBase modifier,
List <apModifierParamSetGroup> paramSetGroups)
{
//apCalculatedResultParam.RESULT_TYPE targetResultType = modifier.CalculatedResultType;
//추가
//요청한 Modifier가 BoneTransform을 지원하는 경우
//Rigging은 비활성화 되어서는 안된다.
bool isRiggingAvailable = false;
if (modifier != null && modifier.IsTarget_Bone && modifier.ModifierType != apModifierBase.MODIFIER_TYPE.Rigging)
{
isRiggingAvailable = true; //Rigging은 허용하자
}
for (int i = 0; i < _modifiers.Count; i++)
{
if (_modifiers[i] == modifier && modifier != null && paramSetGroups != null && paramSetGroups.Count > 0)
{
//_modifiers[i]._isActive_InEditorExclusive = true;
_modifiers[i]._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.ExclusiveEnabled;
for (int iP = 0; iP < _modifiers[i]._paramSetGroup_controller.Count; iP++)
{
apModifierParamSetGroup paramSetGroup = _modifiers[i]._paramSetGroup_controller[iP];
if (paramSetGroups.Contains(paramSetGroup))
{
paramSetGroup._isEnabledExclusive = true;
}
else
{
paramSetGroup._isEnabledExclusive = false;
}
}
//Active라 하더라도, ParamSet에도 처리 여부를 결정해야한다.
//Modifier를 False 했다면 CalculateParam은 True로 해도 된다.
//List<apCalculatedResultParam> calParamList = _modifiers[i]._calculatedResultParams;
//for (int iCal = 0; iCal < calParamList.Count; iCal++)
//{
// for (int iParamSetGroups = 0; iParamSetGroups < paramSetGroups.Count; iParamSetGroups++)
// {
// apModifierParamSetGroup paramSetGroup = paramSetGroups[iParamSetGroups];
// calParamList[iCal].ActiveConditionParamList(paramSetGroup._paramSetList);
// }
//}
}
else if (isRiggingAvailable && _modifiers[i].ModifierType == apModifierBase.MODIFIER_TYPE.Rigging)
{
//만약 Rigging 타입은 예외로 친다면..
_modifiers[i]._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.ExclusiveEnabled;
for (int iP = 0; iP < _modifiers[i]._paramSetGroup_controller.Count; iP++)
{
_modifiers[i]._paramSetGroup_controller[iP]._isEnabledExclusive = true;
}
}
else
{
////타입이 같은가 (다른건 해도 괜찮다.)
//if(_modifiers[i].CalculatedResultType == targetResultType)
//{
// _modifiers[i]._isActive_InEditorExclusive = false;
//}
//else
//{
// _modifiers[i]._isActive_InEditorExclusive = true;
//}
//일단 다 빼보자
//_modifiers[i]._isActive_InEditorExclusive = false;
_modifiers[i]._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.Disabled;
for (int iP = 0; iP < _modifiers[i]._paramSetGroup_controller.Count; iP++)
{
apModifierParamSetGroup paramSetGroup = _modifiers[i]._paramSetGroup_controller[iP];
paramSetGroup._isEnabledExclusive = false;
}
////Modifier를 False 했다면 CalculateParam은 True로 해도 된다.
//List<apCalculatedResultParam> calParamList = _modifiers[i]._calculatedResultParams;
//for (int iCal = 0; iCal < calParamList.Count; iCal++)
//{
// calParamList[iCal].ActiveAllParamList();
//}
}
}
//Child MeshGroup에도 모두 적용하자 - False로..
if (_parentMeshGroup != null)
{
if (_parentMeshGroup._childMeshGroupTransforms != null)
{
for (int i = 0; i < _parentMeshGroup._childMeshGroupTransforms.Count; i++)
{
apTransform_MeshGroup meshGroupTransform = _parentMeshGroup._childMeshGroupTransforms[i];
if (meshGroupTransform._meshGroup != null && meshGroupTransform._meshGroup != _parentMeshGroup)
{
meshGroupTransform._meshGroup._modifierStack.SetExclusiveModifierInEditing(null, null);
}
}
}
}
}
// Bake
//---------------------------------------------------------------------------------
public bool Bake(apModifierBase srcModifier,
apModifierParamSetGroup srcModParamSetGroup,
apModifiedMesh srcModMesh,
apPortrait portrait)
{
_portrait = portrait;
_rootMeshGroupUniqueID = srcModMesh._meshGroupUniqueID_Modifier;
_meshUniqueID = srcModMesh._meshUniqueID;
_transformUniqueID = srcModMesh._transformUniqueID;
//_boneUniqueID = srcModMesh._boneUniqueID;
_isMeshTransform = srcModMesh._isMeshTransform;
apOptTransform rootTransform = _portrait.GetOptTransformAsMeshGroup(_rootMeshGroupUniqueID);
apOptTransform targetTransform = _portrait.GetOptTransform(_transformUniqueID);
if (targetTransform == null)
{
Debug.LogError("Bake 실패 : 찾을 수 없는 연결된 OptTransform [" + _transformUniqueID + "]");
Debug.LogError("이미 삭제된 객체에 연결된 ModMesh가 아닌지 확인해보세염");
return(false);
}
apOptMesh targetMesh = null;
if (targetTransform._unitType == apOptTransform.UNIT_TYPE.Mesh)
{
targetMesh = targetTransform._childMesh;
}
if (rootTransform == null)
{
Debug.LogError("ModifiedMesh 연동 에러 : 알수 없는 RootTransform");
return(false);
}
_rootTransform = rootTransform;
_targetTransform = targetTransform;
_targetMesh = targetMesh;
//각각의 타입
_dataType = DATA_TYPE.None;
//1. Vertex
if ((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.VertexPosList) != 0)
{
Bake_Vertex(srcModMesh._vertices);
}
//2. Transform
if ((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.TransformMatrix) != 0)
{
Bake_Transform(srcModMesh._transformMatrix);
}
//3. Rigging
if ((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.BoneVertexWeightList) != 0)
{
Bake_VertexRigs(srcModMesh._vertRigs);
}
//4. Physics
if ((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.VertexWeightList_Physics) != 0 &&
srcModMesh._isUsePhysicParam)
{
Bake_Physics(srcModMesh.PhysicParam, srcModMesh._vertWeights, portrait);
}
if (((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.VertexPosList) != 0) ||
((int)(srcModMesh._modValueType & apModifiedMesh.MOD_VALUE_TYPE.TransformMatrix) != 0)
)
{
//Morph, Transform 모디파이어에서..
//5. Color
if (srcModifier._isColorPropertyEnabled &&
srcModParamSetGroup._isColorPropertyEnabled)
{
//색상 옵션이 켜진 경우
Color meshColor = srcModMesh._meshColor;
if (!srcModMesh._isVisible)
{
meshColor.a = 0.0f;
}
Bake_Color(meshColor, srcModMesh._isVisible);
}
//6. Extra
if (srcModMesh._isExtraValueEnabled &&
(srcModMesh._extraValue._isDepthChanged || srcModMesh._extraValue._isTextureChanged)
)
{
//Extra 옵션이 켜진 경우
Bake_ExtraValue(srcModMesh);
}
}
return(true);
}
public void Bake(apPortrait portrait, apOptModifierUnitBase parentModifier, apModifierParamSetGroup srcParamSetGroup, bool isAnimated, bool isUseModMeshSet)
{
_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, isUseModMeshSet);
_paramSetList.Add(optParamSet);
}
_isEnabled = srcParamSetGroup._isEnabled;
_layerIndex = srcParamSetGroup._layerIndex;
_layerWeight = srcParamSetGroup._layerWeight;
if (!isAnimated)
{
_blendMethod = srcParamSetGroup._blendMethod;
}
else
{
_blendMethod = apModifierParamSetGroup.BLEND_METHOD.Additive; //<<애니메이션에서는 Additive 강제
}
_isColorPropertyEnabled = srcParamSetGroup._isColorPropertyEnabled; //<<추가.
// 삭제 19.5.20 : _calculatedWeightedVertexList 변수 삭제
//_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);
}
/// <summary>Layer_ParamSetGroup의 초기화</summary>
/// <param name="paramSetGroup"></param>
public apCalculatedLog(apModifierParamSetGroup paramSetGroup)
{
_logType = LOG_TYPE.Layer_ParamSetGroup;
_paramSetGroup = paramSetGroup;
}
