public bool Bake(apModifiedBone srcModBone, apPortrait portrait) { _portrait = portrait; _meshGroupID_Bone = srcModBone._meshGropuUniqueID_Bone; apOptTransform meshGroupTransform = portrait.GetOptTransformAsMeshGroup(_meshGroupID_Bone); if (meshGroupTransform == null) { Debug.LogError("[ModBone] Bake 실패 : 찾을 수 없는 OptTransform [" + _meshGroupID_Bone + "]"); return(false); } _transformUniqueID = meshGroupTransform._transformID; _meshGroup_Bone = meshGroupTransform; _boneID = srcModBone._boneID; _bone = meshGroupTransform.GetBone(_boneID); if (_bone == null) { Debug.LogError("[ModBone] Bake 실패 : 찾을 수 없는 Bone [" + _boneID + "]"); return(false); } _transformMatrix = new apMatrix(srcModBone._transformMatrix); return(true); }
private bool AddBoneToParamSet(apModifierParamSet paramSet, apTransform_MeshGroup meshGroupTransform, apBone bone) { if (!_parentModifier.IsTarget_Bone) { return(false); } bool isExist = paramSet._boneData.Exists(delegate(apModifiedBone a) { return(a._bone == bone); }); if (!isExist) { apMeshGroup parentMeshGroupOfBone = GetParentMeshGroupOfBone(bone); if (parentMeshGroupOfBone == null) { return(false); } apRenderUnit targetRenderUnit = _parentModifier._meshGroup.GetRenderUnit(meshGroupTransform); apModifiedBone modBone = new apModifiedBone(); modBone.Init(_parentModifier._meshGroup._uniqueID, parentMeshGroupOfBone._uniqueID, meshGroupTransform._transformUniqueID, bone); modBone.Link(_parentModifier._meshGroup, parentMeshGroupOfBone, bone, targetRenderUnit, meshGroupTransform); paramSet._boneData.Add(modBone); } return(!isExist); }
public void Init(int uniqueID, int frameIndex, bool isIntControlParamLayer) { _uniqueID = uniqueID; _frameIndex = frameIndex; _isLoopAsStart = false; _isLoopAsEnd = false; _loopFrameIndex = -1; //_conSyncValue_Bool = false; _conSyncValue_Int = 0; _conSyncValue_Float = 0.0f; _conSyncValue_Vector2 = Vector2.zero; //_conSyncValue_Vector3 = Vector3.zero; //_conSyncValue_Color = Color.black; _linkedParamSet_Editor = null; _linkedModMesh_Editor = null; _linkedModBone_Editor = null; if (isIntControlParamLayer) { _curveKey.SetTangentType(apAnimCurve.TANGENT_TYPE.Constant, apAnimCurve.KEY_POS.NEXT); _curveKey.SetTangentType(apAnimCurve.TANGENT_TYPE.Constant, apAnimCurve.KEY_POS.PREV); } _prevRotationBiasMode = ROTATION_BIAS.None; _nextRotationBiasMode = ROTATION_BIAS.None; _prevRotationBiasCount = 0; _nextRotationBiasCount = 0; }
public ParamKeyValueSet(apModifierParamSetGroup keyParamSetGroup, apModifierParamSet paramSet, apModifiedBone modifiedValue) { _keyParamSetGroup = keyParamSetGroup; _paramSet = paramSet; _modifiedMesh = null; _modifiedBone = modifiedValue; _layerIndx = _paramSet._parentParamSetGroup._layerIndex; }
public override bool Save(object target, string strParam) { base.Save(target, strParam); apAnimKeyframe keyframe = target as apAnimKeyframe; if (keyframe == null) { return(false); } _key_TimelineLayer = keyframe._parentTimelineLayer; if (_key_TimelineLayer == null) { return(false); } _animCurve = new apAnimCurve(keyframe._curveKey, keyframe._frameIndex); _isKeyValueSet = keyframe._isKeyValueSet; //_conSyncValue_Bool = keyframe._conSyncValue_Bool; _conSyncValue_Int = keyframe._conSyncValue_Int; _conSyncValue_Float = keyframe._conSyncValue_Float; _conSyncValue_Vector2 = keyframe._conSyncValue_Vector2; //_conSyncValue_Vector3 = keyframe._conSyncValue_Vector3; //_conSyncValue_Color = keyframe._conSyncValue_Color; _vertices.Clear(); _transformMatrix = new apMatrix(); _meshColor = new Color(0.5f, 0.5f, 0.5f, 1.0f); _isVisible = true; if (keyframe._linkedModMesh_Editor != null) { apModifiedMesh modMesh = keyframe._linkedModMesh_Editor; _vertices.Clear(); int nVert = modMesh._vertices.Count; for (int i = 0; i < nVert; i++) { apModifiedVertex modVert = modMesh._vertices[i]; _vertices.Add(new VertData(modVert._vertex, modVert._deltaPos)); } _transformMatrix = new apMatrix(modMesh._transformMatrix); _meshColor = modMesh._meshColor; _isVisible = modMesh._isVisible; } else if (keyframe._linkedModBone_Editor != null) { apModifiedBone modBone = keyframe._linkedModBone_Editor; _transformMatrix = new apMatrix(modBone._transformMatrix); } return(true); }
//-------------------------------------------------------------------- // 1-2. ModBone //-------------------------------------------------------------------- public void Copy_ModBone(apModifiedBone modBone, string snapShotName) { _clipboard_ModBone = new apSnapShotStackUnit(snapShotName); bool result = _clipboard_ModBone.SetSnapShot_ModBone(modBone, "Clipboard"); if (!result) { _clipboard_ModBone = null; //<<저장 불가능하다. } }
/// <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 override bool Load(object targetObj) { apAnimKeyframe keyframe = targetObj as apAnimKeyframe; if (keyframe == null) { return(false); } keyframe._curveKey = new apAnimCurve(_animCurve, keyframe._frameIndex); keyframe._isKeyValueSet = _isKeyValueSet; //keyframe._conSyncValue_Bool = _conSyncValue_Bool; keyframe._conSyncValue_Int = _conSyncValue_Int; keyframe._conSyncValue_Float = _conSyncValue_Float; keyframe._conSyncValue_Vector2 = _conSyncValue_Vector2; //keyframe._conSyncValue_Vector3 = _conSyncValue_Vector3; //keyframe._conSyncValue_Color = _conSyncValue_Color; if (keyframe._linkedModMesh_Editor != null) { apModifiedMesh modMesh = keyframe._linkedModMesh_Editor; VertData vertData = null; apModifiedVertex modVert = null; int nVert = _vertices.Count; for (int i = 0; i < nVert; i++) { vertData = _vertices[i]; modVert = modMesh._vertices.Find(delegate(apModifiedVertex a) { return(a._vertex == vertData._key_Vert); }); if (modVert != null) { modVert._deltaPos = vertData._deltaPos; } } modMesh._transformMatrix.SetMatrix(_transformMatrix); modMesh._meshColor = _meshColor; modMesh._isVisible = _isVisible; } else if (keyframe._linkedModBone_Editor != null) { apModifiedBone modBone = keyframe._linkedModBone_Editor; modBone._transformMatrix.SetMatrix(_transformMatrix); } return(true); }
public override bool Load(object targetObj) { apModifiedBone modBone = targetObj as apModifiedBone; if (modBone == null) { return(false); } modBone._transformMatrix.SetMatrix(_transformMatrix); modBone._transformMatrix.MakeMatrix(); return(true); }
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 override bool Save(object target, string strParam) { base.Save(target, strParam); apModifiedBone modBone = target as apModifiedBone; if (modBone == null) { return(false); } _key_MeshGroupOfMod = modBone._meshGroup_Modifier; _key_MeshGroupOfBone = modBone._meshGroup_Bone; _key_Bone = modBone._bone; _transformMatrix.SetMatrix(modBone._transformMatrix); return(true); }
public void Init(int uniqueID, int frameIndex) { _uniqueID = uniqueID; _frameIndex = frameIndex; _isLoopAsStart = false; _isLoopAsEnd = false; _loopFrameIndex = -1; //_conSyncValue_Bool = false; _conSyncValue_Int = 0; _conSyncValue_Float = 0.0f; _conSyncValue_Vector2 = Vector2.zero; //_conSyncValue_Vector3 = Vector3.zero; //_conSyncValue_Color = Color.black; _linkedParamSet_Editor = null; _linkedModMesh_Editor = null; _linkedModBone_Editor = null; }
public bool IsPastable(apModifiedBone targetModBone) { if (targetModBone == null) { return(false); } if (_clipboard_ModBone == null) { return(false); } //만약, 복사-붙여넣기 불가능한 객체이면 생략한다. bool isKeySync = _clipboard_ModBone.IsKeySyncable(targetModBone); if (!isKeySync) { return(false); } return(true); }
// Functions //-------------------------------------------- public override bool IsKeySyncable(object target) { if (!(target is apModifiedBone)) { return(false); } apModifiedBone targetModBone = target as apModifiedBone; if (targetModBone == null) { return(false); } //Key 체크를 하자 if (targetModBone._meshGroup_Modifier != _key_MeshGroupOfMod || targetModBone._meshGroup_Bone != _key_MeshGroupOfBone || targetModBone._bone != _key_Bone) { return(false); } return(true); }
public bool SetSnapShot_ModBone(apModifiedBone modBone, string strParam) { _snapShot = new apSnapShot_ModifiedBone(); return(_snapShot.Save(modBone, strParam)); }
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); }
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 BakeModifierParamSet(apModifierParamSet srcParamSet, apPortrait portrait) { //switch (srcParamSet._syncTarget) //{ // case apModifierParamSet.SYNC_TARGET.Static: // _syncTarget = SYNC_TARGET.Static; // break; // case apModifierParamSet.SYNC_TARGET.Controller: // _syncTarget = SYNC_TARGET.Controller; // break; // case apModifierParamSet.SYNC_TARGET.KeyFrame: // _syncTarget = SYNC_TARGET.KeyFrame; // break; // default: // Debug.LogError("연동 에러 : ParamSet에 정의되지 않은 타입 : " + srcParamSet._syncTarget); // break; //} //_controlKeyName = srcParamSet._controlKeyName; //_conSyncValue_Bool = srcParamSet._conSyncValue_Bool; _conSyncValue_Int = srcParamSet._conSyncValue_Int; _conSyncValue_Float = srcParamSet._conSyncValue_Float; _conSyncValue_Vector2 = srcParamSet._conSyncValue_Vector2; //_conSyncValue_Vector3 = srcParamSet._conSyncValue_Vector3; //_conSyncValue_Color = srcParamSet._conSyncValue_Color; _keyframeUniqueID = srcParamSet._keyframeUniqueID; _syncKeyframe = null; _overlapWeight = srcParamSet._overlapWeight; //OverlapWeight를 집어넣자 _meshData.Clear(); _boneData.Clear(); //SrcModifier ParamSet의 ModMesh, ModBone을 Bake해주자 //Debug.LogError("TODO : Bone 데이터 연동"); for (int i = 0; i < srcParamSet._meshData.Count; i++) { apModifiedMesh srcModMesh = srcParamSet._meshData[i]; apOptModifiedMesh optModMesh = new apOptModifiedMesh(); bool isResult = optModMesh.Bake(srcModMesh, portrait); if (isResult) { _meshData.Add(optModMesh); } } //추가 : ModBone for (int i = 0; i < srcParamSet._boneData.Count; i++) { apModifiedBone srcModBone = srcParamSet._boneData[i]; apOptModifiedBone optModBone = new apOptModifiedBone(); bool isResult = optModBone.Bake(srcModBone, portrait); if (isResult) { _boneData.Add(optModBone); } } }
public override bool Load(object targetObj) { apAnimKeyframe keyframe = targetObj as apAnimKeyframe; if (keyframe == null) { return(false); } keyframe._curveKey = new apAnimCurve(_animCurve, keyframe._frameIndex); keyframe._isKeyValueSet = _isKeyValueSet; //keyframe._conSyncValue_Bool = _conSyncValue_Bool; keyframe._conSyncValue_Int = _conSyncValue_Int; keyframe._conSyncValue_Float = _conSyncValue_Float; keyframe._conSyncValue_Vector2 = _conSyncValue_Vector2; //keyframe._conSyncValue_Vector3 = _conSyncValue_Vector3; //keyframe._conSyncValue_Color = _conSyncValue_Color; if (keyframe._linkedModMesh_Editor != null) { apModifiedMesh modMesh = keyframe._linkedModMesh_Editor; VertData vertData = null; apModifiedVertex modVert = null; int nVert = _vertices.Count; for (int i = 0; i < nVert; i++) { vertData = _vertices[i]; modVert = modMesh._vertices.Find(delegate(apModifiedVertex a) { return(a._vertex == vertData._key_Vert); }); if (modVert != null) { modVert._deltaPos = vertData._deltaPos; } } modMesh._transformMatrix.SetMatrix(_transformMatrix); modMesh._meshColor = _meshColor; modMesh._isVisible = _isVisible; //추가 3.29 : ExtraProperty도 복사 modMesh._isExtraValueEnabled = _isExtraValueEnabled; if (modMesh._extraValue == null) { modMesh._extraValue = new apModifiedMesh.ExtraValue(); modMesh._extraValue.Init(); } if (_isExtraValueEnabled) { if (_extraValue != null) { modMesh._extraValue._isDepthChanged = _extraValue._isDepthChanged; modMesh._extraValue._deltaDepth = _extraValue._deltaDepth; modMesh._extraValue._isTextureChanged = _extraValue._isTextureChanged; modMesh._extraValue._linkedTextureData = _extraValue._linkedTextureData; modMesh._extraValue._textureDataID = _extraValue._textureDataID; modMesh._extraValue._weightCutout = _extraValue._weightCutout; modMesh._extraValue._weightCutout_AnimPrev = _extraValue._weightCutout_AnimPrev; modMesh._extraValue._weightCutout_AnimNext = _extraValue._weightCutout_AnimNext; } } else { modMesh._extraValue.Init(); } } else if (keyframe._linkedModBone_Editor != null) { apModifiedBone modBone = keyframe._linkedModBone_Editor; modBone._transformMatrix.SetMatrix(_transformMatrix); } return(true); }
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 void LinkModBone_Editor(apModifierParamSet paramSet, apModifiedBone modBone) { _linkedParamSet_Editor = paramSet; _linkedModMesh_Editor = null; _linkedModBone_Editor = modBone; }
public void BakeModifierParamSet(apModifierParamSet srcParamSet, apPortrait portrait, bool isUseModMeshSet) { _conSyncValue_Int = srcParamSet._conSyncValue_Int; _conSyncValue_Float = srcParamSet._conSyncValue_Float; _conSyncValue_Vector2 = srcParamSet._conSyncValue_Vector2; _keyframeUniqueID = srcParamSet._keyframeUniqueID; _syncKeyframe = null; _overlapWeight = srcParamSet._overlapWeight; //OverlapWeight를 집어넣자 _meshData.Clear(); _boneData.Clear(); //19.5.23 : meshSetData 추가 if (_meshSetData == null) { _meshSetData = new List <apOptModifiedMeshSet>(); } _meshSetData.Clear(); _isUseModMeshSet = isUseModMeshSet; //<<이 값이 1.1.7부터는 true가 된다. if (!_isUseModMeshSet) { //이전버전 //SrcModifier ParamSet의 ModMesh, ModBone을 Bake해주자 for (int i = 0; i < srcParamSet._meshData.Count; i++) { apModifiedMesh srcModMesh = srcParamSet._meshData[i]; apOptModifiedMesh optModMesh = new apOptModifiedMesh(); bool isResult = optModMesh.Bake(srcModMesh, portrait); if (isResult) { _meshData.Add(optModMesh); } } } else { //변경된 버전 : 19.5.23 (v.1.1.7) for (int i = 0; i < srcParamSet._meshData.Count; i++) { apModifiedMesh srcModMesh = srcParamSet._meshData[i]; apOptModifiedMeshSet optModMeshSet = new apOptModifiedMeshSet(); bool isResult = optModMeshSet.Bake( srcParamSet._parentParamSetGroup._parentModifier, srcParamSet._parentParamSetGroup, srcModMesh, portrait); if (isResult) { _meshSetData.Add(optModMeshSet); } } } //ModBone for (int i = 0; i < srcParamSet._boneData.Count; i++) { apModifiedBone srcModBone = srcParamSet._boneData[i]; apOptModifiedBone optModBone = new apOptModifiedBone(); bool isResult = optModBone.Bake(srcModBone, portrait); if (isResult) { _boneData.Add(optModBone); } } }
/// <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); } }
/// <summary>Modified의 초기화</summary> public apCalculatedLog(apModifiedBone modBone) { _logType = LOG_TYPE.Modified; _modBone = modBone; }