Ejemplo n.º 1
0
        // 실제로 연결된 데이터를 가져오자
        //-------------------------------------------------------------------------------
        /// <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;
            }));
        }
Ejemplo n.º 2
0
 public void AddParamSetGroup(apModifierParamSetGroup paramSetGroup)
 {
     if (!_paramSetGroups.Contains(paramSetGroup))
     {
         _paramSetGroups.Add(paramSetGroup);
     }
 }
Ejemplo n.º 3
0
 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);
        }
Ejemplo n.º 5
0
        /// <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도 현재는 초기화 할게 없다.
                        }
                    }
                }
            }
        }
Ejemplo n.º 6
0
            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;
 }
Ejemplo n.º 8
0
 public void SetParamSetGroup(apModifierParamSetGroup paramSetGroup)
 {
     _keyParamSetGroup = paramSetGroup;
     //_controlParam = _keyParamSetGroup._keyControlParam;
 }
Ejemplo n.º 9
0
 public void LinkParamSetGroup(apModifierParamSetGroup paramSetGroup)
 {
     _parentParamSetGroup = paramSetGroup;
 }
Ejemplo n.º 10
0
        /// <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);
            }
        }
Ejemplo n.º 11
0
        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();
                }
            }
        }
Ejemplo n.º 12
0
        /// <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);
                        }
                    }
                }
            }
        }
Ejemplo n.º 13
0
        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);
                        }
                    }
                }
            }
        }
Ejemplo n.º 14
0
        // 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);
        }
Ejemplo n.º 16
0
 /// <summary>Layer_ParamSetGroup의 초기화</summary>
 /// <param name="paramSetGroup"></param>
 public apCalculatedLog(apModifierParamSetGroup paramSetGroup)
 {
     _logType       = LOG_TYPE.Layer_ParamSetGroup;
     _paramSetGroup = paramSetGroup;
 }