public void SetMesh(apMeshGroup meshGroup, apTransform_Mesh meshTransform, apRenderUnit parentRenderUnit)
{
_unitType = UNIT_TYPE.Mesh;
_meshGroup = meshGroup;
_meshGroupTransform = null;
_meshTransform = meshTransform;
_meshTransform._linkedRenderUnit = this;
_depth = 0;
if (parentRenderUnit != null)
{
_depth += parentRenderUnit._depth;
}
if (_meshGroupTransform != null)
{
_depth += _meshGroupTransform._depth;
}
_depth += meshTransform._depth;
if (parentRenderUnit != null)
{
parentRenderUnit._childRenderUnits.Add(this);
_parentRenderUnit = parentRenderUnit;
}
}
public void SetGroup(apMeshGroup meshGroup, apTransform_MeshGroup meshGroupTransform, apRenderUnit parentRenderUnit)
{
_unitType = UNIT_TYPE.GroupNode;
_meshGroup = meshGroup;
_meshGroupTransform = meshGroupTransform;
_meshTransform = null;
//역으로 Link를 하자
_meshGroupTransform._linkedRenderUnit = this;
_depth = 0;
if (_meshTransform != null)
{
_depth += _meshTransform._depth;
}
if (parentRenderUnit != null)
{
_depth += parentRenderUnit._depth;
}
if (meshGroupTransform != null)
{
//루트가 아니라면 Mesh Group Transform도 있다.
_depth += _meshGroupTransform._depth;
}
if (parentRenderUnit != null)
{
parentRenderUnit._childRenderUnits.Add(this);
_parentRenderUnit = parentRenderUnit;
}
}
// Init
//--------------------------------------------------------------------
public void Init(apEditor editor, object loadKey, apMeshGroup srcMeshGroup, FUNC_SELECT_TRANSFORM_RESULT funcResult)
{
_editor = editor;
_loadKey = loadKey;
//_srcMeshGroup = srcMeshGroup;
_funcResult = funcResult;
//타겟을 검색하자
_meshes.Clear();
_meshGroups.Clear();
for (int i = 0; i < _editor._portrait._meshes.Count; i++)
{
_meshes.Add(_editor._portrait._meshes[i]);
}
for (int i = 0; i < _editor._portrait._meshGroups.Count; i++)
{
apMeshGroup meshGroup = _editor._portrait._meshGroups[i];
if (meshGroup == srcMeshGroup)
{
continue;
}
//재귀적으로 이미 포함된 MeshGroup인지 판단한다.
//추가 12.03 : 그 반대도 포함해야 한다.
apTransform_MeshGroup childMeshGroupTransform = srcMeshGroup.FindChildMeshGroupTransform(meshGroup);
apTransform_MeshGroup childMeshGroupTransform_Rev = meshGroup.FindChildMeshGroupTransform(srcMeshGroup);
if (childMeshGroupTransform == null && childMeshGroupTransform_Rev == null)
{
//child가 아닐때
_meshGroups.Add(meshGroup);
}
}
}
public void UpdateBeforeBake(apPortrait portrait, apMeshGroup mainMeshGroup, apTransform_MeshGroup mainMeshGroupTransform)
{
//Bake 전에 업데이트할게 있으면 여기서 업데이트하자
//1. VertRig의 LocalPos 갱신을 여기서 하자
#region [미사용 코드]
//if(_vertRigs != null && _vertRigs.Count > 0)
//{
// apModifiedVertexRig vertRig = null;
// //기존 링크 말고, Bake 직전의 Transform 등을 검색하여 값을 넣어주자
// apTransform_Mesh meshTransform = mainMeshGroup.GetMeshTransformRecursive(_transformUniqueID);
// if (meshTransform != null)
// {
// apMesh mesh = meshTransform._mesh;
// if (mesh != null)
// {
// for (int iVR = 0; iVR < _vertRigs.Count; iVR++)
// {
// vertRig = _vertRigs[iVR];
// apVertex vert = vertRig._vertex;
// for (int iW = 0; iW < vertRig._weightPairs.Count; iW++)
// {
// apModifiedVertexRig.WeightPair weightPair = vertRig._weightPairs[iW];
// weightPair.CalculateLocalPos(vert._pos, mesh.Matrix_VertToLocal, meshTransform._matrix_TFResult_WorldWithoutMod, weightPair._bone._defaultMatrix);
// }
// }
// }
// }
//}
#endregion
}
private static int MakeSubUnitsFromMeshGroupTransformRecursive(
apMeshGroup rootMeshGroup,
apTransform_MeshGroup meshGroupTransform,
int startUnitID,
List <apRetargetSubUnit> transforms_All,
List <apRetargetSubUnit> transforms_Root,
apRetargetSubUnit parentSubUnit
)
{
//MeshGroup Transform을 추가한다.
apRetargetSubUnit newGroupSubUnit = new apRetargetSubUnit();
newGroupSubUnit.SetSubData(startUnitID, null, meshGroupTransform, null, parentSubUnit);
transforms_All.Add(newGroupSubUnit);
if (parentSubUnit == null)
{
transforms_Root.Add(newGroupSubUnit);
}
startUnitID++;
if (meshGroupTransform._meshGroup != null && meshGroupTransform._meshGroup != rootMeshGroup)
{
if (meshGroupTransform._meshGroup._childMeshTransforms != null)
{
for (int i = 0; i < meshGroupTransform._meshGroup._childMeshTransforms.Count; i++)
{
//MeshTransform을 추가한다.
apTransform_Mesh meshTransform = meshGroupTransform._meshGroup._childMeshTransforms[i];
apRetargetSubUnit newSubUnit = new apRetargetSubUnit();
newSubUnit.SetSubData(startUnitID, meshTransform, null, null, newGroupSubUnit);
startUnitID++;
transforms_All.Add(newSubUnit);
}
}
//하위에 다른 MeshGroup Transform이 있는 경우
if (meshGroupTransform._meshGroup._childMeshGroupTransforms != null)
{
//재귀 호출을 한다
for (int i = 0; i < meshGroupTransform._meshGroup._childMeshGroupTransforms.Count; i++)
{
apTransform_MeshGroup childMeshGroup = meshGroupTransform._meshGroup._childMeshGroupTransforms[i];
startUnitID = MakeSubUnitsFromMeshGroupTransformRecursive(
rootMeshGroup,
childMeshGroup,
startUnitID,
transforms_All,
transforms_Root,
newGroupSubUnit
);
}
}
}
return(startUnitID);
}
public apPSDSetLayer GetLayer(apTransform_MeshGroup meshGroupTransform)
{
return(_layers.Find(delegate(apPSDSetLayer a)
{
return a._transformID == meshGroupTransform._transformUniqueID && !a._isImageLayer;
}));
}
// Init
//----------------------------------------------
public apRetargetSubUnit()
{
_isImported = false;
_targetMeshTransform = null;
_targetMeshGroupTransform = null;
_targetBone = null;
}
//TODO Link 등등
//에디터에서 제대로 Link를 해야한다.
public void Link(apMeshGroup meshGroup_Modifier, apMeshGroup meshGroup_Bone, apBone bone, apRenderUnit renderUnit, apTransform_MeshGroup meshGroupTransform)
{
_meshGroup_Modifier = meshGroup_Modifier;
_meshGroup_Bone = meshGroup_Bone;
_bone = bone;
_renderUnit = renderUnit;
_meshGroupTransform = meshGroupTransform;
//if (_meshGroup_Bone != meshGroup_Modifier)
//{
// //Debug.Log(" ------------Sub Bone의 Link ------------");
// if (_renderUnit == null)
// {
// //Debug.LogError("<<< Render Unit이 Null이다. >>> ");
// }
// Debug.Log("meshGroup_Modifier : " + (meshGroup_Modifier == null ? "NULL" : meshGroup_Modifier._name));
// Debug.Log("_meshGroup_Bone : " + (_meshGroup_Bone == null ? "NULL" : _meshGroup_Bone._name));
// Debug.Log("_bone : " + (_bone == null ? "NULL" : _bone._name));
// Debug.Log("_meshGroupTransform : " + (_meshGroupTransform == null ? "NULL" : _meshGroupTransform._nickName));
// Debug.Log("_transformUniqueID : " + _transformUniqueID);
//}
}
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 bool IsSubMeshGroupInGroup(apTransform_MeshGroup subMeshGroupTransform)
{
if (subMeshGroupTransform == null)
{
return(false);
}
return(_syncTransform_MeshGroup.Contains(subMeshGroupTransform));
}
//TODO Link 등등
//에디터에서 제대로 Link를 해야한다.
public void Link(apMeshGroup meshGroup_Modifier, apMeshGroup meshGroup_Bone, apBone bone, apRenderUnit renderUnit, apTransform_MeshGroup meshGroupTransform)
{
_meshGroup_Modifier = meshGroup_Modifier;
_meshGroup_Bone = meshGroup_Bone;
_bone = bone;
_renderUnit = renderUnit;
_meshGroupTransform = meshGroupTransform;
}
public override bool Save(object target, string strParam)
{
base.Save(target, strParam);
apModifiedMesh modMesh = target as apModifiedMesh;
if (modMesh == null)
{
return(false);
}
_key_MeshGroupOfMod = modMesh._meshGroupOfModifier;
_key_MeshGroupOfTransform = modMesh._meshGroupOfTransform;
_key_MeshTransform = null;
_key_MeshGroupTransform = null;
_key_RenderUnit = null;
if (modMesh._transform_Mesh != null)
{
_key_MeshTransform = modMesh._transform_Mesh;
}
if (modMesh._transform_MeshGroup != null)
{
_key_MeshGroupTransform = modMesh._transform_MeshGroup;
}
_key_RenderUnit = modMesh._renderUnit;
_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;
_isExtraValueEnabled = false;
_extraValue = null;
//추가 3.29 : ExtraValue도 복사
if (modMesh._isExtraValueEnabled)
{
_isExtraValueEnabled = true;
_extraValue = new ExtraDummyValue(modMesh._extraValue);
}
return(true);
}
public bool IsContainMeshGroupTransform(apTransform_MeshGroup meshGroupTransform)
{
if (meshGroupTransform == null)
{
return(false);
}
return(_meshData.Exists(delegate(apModifiedMesh a)
{
return !a._isMeshTransform && a._transform_MeshGroup == meshGroupTransform;
}));
}
/// <summary>
/// MeshGroupTransform과 ModMesh를 연결한다.
/// </summary>
/// <param name="meshGroupOfMod">Modifier가 속한 MeshGroup</param>
/// <param name="meshGroupOfTransform">Transform이 속한 MeshGroup</param>
public void Link_MeshGroupTransform(apMeshGroup meshGroupOfMod, apMeshGroup meshGroupOfTransform, apTransform_MeshGroup meshGroupTransform, apRenderUnit renderUnit)
{
_meshGroupOfModifier = meshGroupOfMod;
_meshGroupOfTransform = meshGroupOfTransform;
_transform_MeshGroup = meshGroupTransform;
_renderUnit = renderUnit;
RefreshModifiedValues(meshGroupOfMod._parentPortrait);
}
public bool IsContains_MeshGroupTransform(apMeshGroup meshGroup, apTransform_MeshGroup meshGroupTransform)
{
if (_meshGroupUniqueID_Modifier == meshGroup._uniqueID &&
_transformUniqueID == meshGroupTransform._transformUniqueID &&
_transformUniqueID >= 0 &&
!_isMeshTransform)
{
return(true);
}
return(false);
}
/// <summary>
/// 처리를 도와주는 함수. MeshTransform의 Parent MeshGroup을 검색한다.
/// </summary>
/// <param name="meshTransform"></param>
/// <returns></returns>
private apMeshGroup GetParentMeshGroupOfMeshGroupTransform(apTransform_MeshGroup meshGroupTransform)
{
for (int i = 0; i < _portrait._meshGroups.Count; i++)
{
if (_portrait._meshGroups[i]._childMeshGroupTransforms.Contains(meshGroupTransform))
{
//찾았다!
return(_portrait._meshGroups[i]);
}
}
return(null);
}
// Functions
//------------------------------------------
//추가되었다.
//Bake 전에 업데이트하는 부분
public void UpdateBeforeBake(apPortrait portrait, apMeshGroup mainMeshGroup, apTransform_MeshGroup mainMeshGroupTransform)
{
if (_meshData != null && _meshData.Count > 0)
{
for (int i = 0; i < _meshData.Count; i++)
{
_meshData[i].UpdateBeforeBake(portrait, mainMeshGroup, mainMeshGroupTransform);
}
}
if (_boneData != null && _boneData.Count > 0)
{
for (int i = 0; i < _boneData.Count; i++)
{
_boneData[i].UpdateBeforeBake(portrait, mainMeshGroup, mainMeshGroupTransform);
}
}
}
/// <summary>
/// ParamSetGroup 내의 모든 ParamSet에서 MeshGroupTransform을 포함한 ModMesh를 모두 삭제한다.
/// 주의 메세지를 꼭 출력할 것
/// </summary>
/// <param name="meshGroupTransform"></param>
public void RemoveModifierMeshes(apTransform_MeshGroup meshGroupTransform)
{
apModifierParamSet paramSet = null;
for (int i = 0; i < _paramSetList.Count; i++)
{
paramSet = _paramSetList[i];
int nRemoved = paramSet._meshData.RemoveAll(delegate(apModifiedMesh a)
{
return(a.IsContains_MeshGroupTransform(_parentModifier._meshGroup, meshGroupTransform));
});
if (nRemoved > 0)
{
//Debug.LogError("Remove ModMesh [RemoveModifierMeshes / MeshGroupTransform] : " + meshGroupTransform._nickName + " / " + nRemoved);
}
}
}
private bool AddMeshGroupTransformToParamSet(apModifierParamSet paramSet, apTransform_MeshGroup meshGroupTransform)
{
//if(_parentModifier.ModifiedTargetType != apModifiedMesh.TARGET_TYPE.MeshGroupTransformOnly)
//{
// return false;
//}
if (!_parentModifier.IsTarget_MeshGroupTransform)
{
return(false);
}
bool isExist = paramSet._meshData.Exists(delegate(apModifiedMesh a)
{
return(a.IsContains_MeshGroupTransform(_parentModifier._meshGroup, meshGroupTransform));
});
if (!isExist)
{
apRenderUnit targetRenderUnit = _parentModifier._meshGroup.GetRenderUnit(meshGroupTransform);
if (targetRenderUnit != null)
{
apMeshGroup parentMeshGroupOfTransform = GetParentMeshGroupOfMeshGroupTransform(meshGroupTransform);
if (parentMeshGroupOfTransform == null)
{
//Parent MeshGroup이 없네염
return(false);
}
apModifiedMesh modMesh = new apModifiedMesh();
modMesh.Init(_parentModifier._meshGroup._uniqueID, parentMeshGroupOfTransform._uniqueID, _parentModifier.ModifiedValueType);
modMesh.SetTarget_MeshGroupTransform(meshGroupTransform._transformUniqueID, meshGroupTransform._meshColor2X_Default, meshGroupTransform._isVisible_Default);
//modMesh.Init_MeshGroupTransform(_parentModifier._meshGroup._uniqueID,
// meshGroupTransform._transformUniqueID);
modMesh.Link_MeshGroupTransform(_parentModifier._meshGroup, parentMeshGroupOfTransform, meshGroupTransform, targetRenderUnit);
paramSet._meshData.Add(modMesh);
}
}
return(!isExist);
}
// 에디터 관련 코드
//----------------------------------------------------
public void ActiveAllModifierFromExclusiveEditing()
{
apModifierBase modifier = null;
for (int i = 0; i < _modifiers.Count; i++)
{
modifier = _modifiers[i];
modifier._editorExclusiveActiveMod = apModifierBase.MOD_EDITOR_ACTIVE.Enabled;
for (int iP = 0; iP < modifier._paramSetGroup_controller.Count; iP++)
{
modifier._paramSetGroup_controller[iP]._isEnabledExclusive = true;
}
//List<apCalculatedResultParam> calParamList = modifier._calculatedResultParams;
//for (int iCal = 0; iCal < calParamList.Count; iCal++)
//{
// calParamList[iCal].ActiveAllParamList();
//}
}
//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.ActiveAllModifierFromExclusiveEditing();
}
}
}
}
}
/// <summary>
/// 재활용을 위해 OptTransform 객체를 찾자
/// </summary>
public apOptTransform FindOptTransform(apTransform_Mesh meshTransform, apTransform_MeshGroup meshGroupTransform)
{
//return null;
//_stopwatches[TIMER_TYPE.OptTransform].Start();
apBakeLinkParam resultLinkParam = null;
if (meshTransform != null)
{
int transformID = meshTransform._transformUniqueID;
if (_totalParams_OptTransform.ContainsKey(transformID))
{
apBakeLinkParam curParam = null;
for (int i = 0; i < _totalParams_OptTransform[transformID].Count; i++)
{
curParam = (_totalParams_OptTransform[transformID])[i];
if (!curParam._isRecycled && curParam._isOptGameObject && curParam._optTransform != null)
{
if (curParam._optTransform._unitType == apOptTransform.UNIT_TYPE.Mesh &&
curParam._optTransform._transformID == meshTransform._transformUniqueID)
{
resultLinkParam = curParam;
break;
}
}
}
}
}
else if (meshGroupTransform != null)
{
int transformID = meshGroupTransform._transformUniqueID;
if (_totalParams_OptTransform.ContainsKey(transformID))
{
apBakeLinkParam curParam = null;
for (int i = 0; i < _totalParams_OptTransform[transformID].Count; i++)
{
curParam = (_totalParams_OptTransform[transformID])[i];
if (!curParam._isRecycled && curParam._isOptGameObject && curParam._optTransform != null)
{
if (curParam._optTransform._unitType == apOptTransform.UNIT_TYPE.Group &&
curParam._optTransform._transformID == meshGroupTransform._transformUniqueID)
{
resultLinkParam = curParam;
break;
}
}
}
}
}
//_stopwatches[TIMER_TYPE.OptTransform].Stop();
//_timerCalls[TIMER_TYPE.OptTransform] = _timerCalls[TIMER_TYPE.OptTransform] + 1;
if (resultLinkParam == null)
{
return(null);
}
resultLinkParam._isRecycled = true; //<<Recycle 된걸로 전환
return(resultLinkParam._optTransform);
}
public void Link(apAnimClip animClip, apAnimTimeline timeline)
{
_parentAnimClip = animClip;
_parentTimeline = timeline;
_linkType = _parentTimeline._linkType;
_parentAnimClip._portrait.RegistUniqueID(apIDManager.TARGET.AnimTimelineLayer, _uniqueID);
switch (_linkType)
{
case apAnimClip.LINK_TYPE.AnimatedModifier:
{
switch (_linkModType)
{
case LINK_MOD_TYPE.MeshTransform:
//수정 : 재귀적으로 링크를 수행한다.
_linkedMeshTransform = _parentAnimClip._targetMeshGroup.GetMeshTransformRecursive(_transformID);
if (_linkedMeshTransform == null)
{
_transformID = -1;
}
break;
case LINK_MOD_TYPE.MeshGroupTransform:
//수정 : 재귀적으로 링크를 수행한다.
_linkedMeshGroupTransform = _parentAnimClip._targetMeshGroup.GetMeshGroupTransformRecursive(_transformID);
if (_linkedMeshGroupTransform == null)
{
_transformID = -1;
}
break;
case LINK_MOD_TYPE.Bone:
_linkedBone = _parentAnimClip._targetMeshGroup.GetBoneRecursive(_boneID); //Recursive 방식으로 검색한다.
if (_linkedBone == null)
{
_boneID = -1;
}
break;
case LINK_MOD_TYPE.None:
//?? 이 타입이 들어올리가 없는뎅..
_linkedMeshTransform = null;
_linkedMeshGroupTransform = null;
_linkedBone = null;
_transformID = -1;
_boneID = -1;
break;
}
}
break;
case apAnimClip.LINK_TYPE.ControlParam:
{
_linkedControlParam = _parentAnimClip._portrait.GetControlParam(_controlParamID);
if (_linkedControlParam == null)
{
_controlParamID = -1;
}
}
break;
}
for (int i = 0; i < _keyframes.Count; i++)
{
_keyframes[i].Link(this);
}
}
/// <summary>
/// Physic Modifier내에서의 Gizmo 이벤트 : Vertex 계열 선택시 [단일 선택]
/// </summary>
/// <param name="mousePosGL"></param>
/// <param name="mousePosW"></param>
/// <param name="btnIndex"></param>
/// <param name="selectType"></param>
/// <returns></returns>
public apGizmos.SelectResult Select__Modifier_Physics(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.MeshGroup == null || Editor.Select.Modifier == null)
{
return(null);
}
//(Editing 상태일 때)
//1. Vertex 선택
//2. (Lock 걸리지 않았다면) 다른 Transform을 선택
//(Editing 상태가 아닐 때)
//(Lock 걸리지 않았다면) Transform을 선택한다.
// Child 선택이 가능하면 MeshTransform을 선택. 그렇지 않아면 MeshGroupTransform을 선택해준다.
if (Editor.Select.ModRenderVertListOfMod == null)
{
return(null);
}
int prevSelectedCount = Editor.Select.ModRenderVertListOfMod.Count;
if (!Editor.Controller.IsMouseInGUI(mousePosGL))
{
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
bool isChildMeshTransformSelectable = Editor.Select.Modifier.IsTarget_ChildMeshTransform;
//apGizmos.SELECT_RESULT result = apGizmos.SELECT_RESULT.None;
bool isTransformSelectable = false;
if (Editor.Select.ExEditingMode != apSelection.EX_EDIT.None)
{
//(Editing 상태일 때)
//1. Vertex 선택
//2. (Lock 걸리지 않았다면) 다른 Transform을 선택
bool selectVertex = false;
if (Editor.Select.ExKey_ModMesh != null && Editor.Select.MeshGroup != null)
{
//일단 선택한 Vertex가 클릭 가능한지 체크
if (Editor.Select.ModRenderVertOfMod != null)
{
if (Editor.Select.ModRenderVertListOfMod.Count == 1)
{
if (Editor.Controller.IsVertexClickable(apGL.World2GL(Editor.Select.ModRenderVertOfMod._renderVert._pos_World), mousePosGL))
{
if (selectType == apGizmos.SELECT_TYPE.Subtract)
{
//삭제인 경우 : ModVertWeight를 선택한다.
Editor.Select.RemoveModVertexOfModifier(null, null, Editor.Select.ModRenderVertOfMod._modVertWeight, Editor.Select.ModRenderVertOfMod._renderVert);
}
else
{
//그 외에는 => 그대로 갑시다.
selectVertex = true;
//return apGizmos.SELECT_RESULT.SameSelected;
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
}
else
{
//여러개라고 하네요.
List <apSelection.ModRenderVert> modRenderVerts = Editor.Select.ModRenderVertListOfMod;
for (int iModRenderVert = 0; iModRenderVert < modRenderVerts.Count; iModRenderVert++)
{
apSelection.ModRenderVert modRenderVert = modRenderVerts[iModRenderVert];
if (Editor.Controller.IsVertexClickable(apGL.World2GL(modRenderVert._renderVert._pos_World), mousePosGL))
{
if (selectType == apGizmos.SELECT_TYPE.Subtract)
{
//삭제인 경우
//하나 지우고 끝
//결과는 List의 개수
Editor.Select.RemoveModVertexOfModifier(null, null, modRenderVert._modVertWeight, modRenderVert._renderVert);
}
else if (selectType == apGizmos.SELECT_TYPE.Add)
{
//Add 상태에서 원래 선택된걸 누른다면
//추가인 경우 => 그대로
selectVertex = true;
}
else
{
//만약... new 라면?
//다른건 초기화하고
//얘만 선택해야함
apRenderVertex selectedRenderVert = modRenderVert._renderVert;
apModifiedVertexWeight selectedModVertWeight = modRenderVert._modVertWeight;
Editor.Select.SetModVertexOfModifier(null, null, null, null);
Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, selectedRenderVert);
}
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
}
}
}
if (selectType == apGizmos.SELECT_TYPE.New)
{
//Add나 Subtract가 아닐땐, 잘못 클릭하면 선택을 해제하자 (전부)
Editor.Select.SetModVertexOfModifier(null, null, null, null);
}
if (selectType != apGizmos.SELECT_TYPE.Subtract)
{
if (Editor.Select.ExKey_ModMesh._transform_Mesh != null &&
Editor.Select.ExKey_ModMesh._vertices != null)
{
//선택된 RenderUnit을 고르자
apRenderUnit targetRenderUnit = Editor.Select.MeshGroup.GetRenderUnit(Editor.Select.ExKey_ModMesh._transform_Mesh);
if (targetRenderUnit != null)
{
for (int iVert = 0; iVert < targetRenderUnit._renderVerts.Count; iVert++)
{
apRenderVertex renderVert = targetRenderUnit._renderVerts[iVert];
bool isClick = Editor.Controller.IsVertexClickable(apGL.World2GL(renderVert._pos_World), mousePosGL);
if (isClick)
{
apModifiedVertexWeight selectedModVertWeight = Editor.Select.ExKey_ModMesh._vertWeights.Find(delegate(apModifiedVertexWeight a)
{
return(renderVert._vertex._uniqueID == a._vertexUniqueID);
});
if (selectedModVertWeight != null)
{
if (selectType == apGizmos.SELECT_TYPE.New)
{
Editor.Select.SetModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
else if (selectType == apGizmos.SELECT_TYPE.Add)
{
Editor.Select.AddModVertexOfModifier(null, null, selectedModVertWeight, renderVert);
}
selectVertex = true;
//result = apGizmos.SELECT_RESULT.NewSelected;
break;
}
}
}
}
}
}
}
//Vertex를 선택한게 없다면
//+ Lock 상태가 아니라면
if (!selectVertex && !Editor.Select.IsLockExEditKey)
{
//Transform을 선택
isTransformSelectable = true;
}
}
else
{
//(Editing 상태가 아닐때)
isTransformSelectable = true;
if (Editor.Select.ExKey_ModMesh != null && Editor.Select.IsLockExEditKey)
{
//뭔가 선택된 상태에서 Lock이 걸리면 다른건 선택 불가
isTransformSelectable = false;
}
}
if (isTransformSelectable && selectType == apGizmos.SELECT_TYPE.New)
{
//(Editing 상태가 아닐 때)
//Transform을 선택한다.
apTransform_Mesh selectedMeshTransform = null;
List <apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All; //<<정렬된 Render Unit
for (int iUnit = 0; iUnit < renderUnits.Count; iUnit++)
{
apRenderUnit renderUnit = renderUnits[iUnit];
if (renderUnit._meshTransform != null && renderUnit._meshTransform._mesh != null)
{
if (renderUnit._meshTransform._isVisible_Default && renderUnit._meshColor2X.a > 0.1f) //Alpha 옵션 추가
{
//Debug.LogError("TODO : Mouse Picking 바꿀것");
bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
mousePosGL, renderUnit);
if (isPick)
{
selectedMeshTransform = renderUnit._meshTransform;
//찾았어도 계속 찾는다.
//뒤의 아이템이 "앞쪽"에 있는 것이기 때문
}
}
}
}
if (selectedMeshTransform != null)
{
//만약 ChildMeshGroup에 속한 거라면,
//Mesh Group 자체를 선택해야 한다. <- 추가 : Child Mesh Transform이 허용되는 경우 그럴 필요가 없다.
apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup || isChildMeshTransformSelectable)
{
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
}
else
{
apTransform_MeshGroup childMeshGroupTransform = Editor.Select.MeshGroup.FindChildMeshGroupTransform(parentMeshGroup);
if (childMeshGroupTransform != null)
{
Editor.Select.SetSubMeshGroupInGroup(childMeshGroupTransform);
}
else
{
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
}
}
}
else
{
Editor.Select.SetSubMeshInGroup(null);
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
//개수에 따라 한번더 결과 보정
if (Editor.Select.ModRenderVertListOfMod != null)
{
//return Editor.Select.ModRenderVertListOfMod.Count;
return(apGizmos.SelectResult.Main.SetMultiple <apSelection.ModRenderVert>(Editor.Select.ModRenderVertListOfMod));
}
return(null);
}
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 bool IsMeshGroupTransformContain(apTransform_MeshGroup meshGroupTransform)
{
return(_syncTransform_MeshGroup.Contains(meshGroupTransform));
}
public apGizmos.SelectResult Select__MeshGroup_Setting(Vector2 mousePosGL, Vector2 mousePosW, int btnIndex, apGizmos.SELECT_TYPE selectType)
{
if (Editor.Select.MeshGroup == null)
{
return(null);
}
apTransform_MeshGroup prevSelectedMeshGroupTransform = Editor.Select.SubMeshGroupInGroup;
//apTransform_Mesh prevSelectedMeshTransform = Editor.Select.SubMeshInGroup;
//apGizmos.SELECT_RESULT result = apGizmos.SELECT_RESULT.None;
//int result = 0;
object resultObj = null;
if (Editor.Controller.IsMouseInGUI(mousePosGL))
{
apTransform_Mesh selectedMeshTransform = null;
//정렬된 Render Unit
//List<apRenderUnit> renderUnits = Editor.Select.MeshGroup._renderUnits_All;//<<이전 : RenderUnits_All 이용
List <apRenderUnit> renderUnits = Editor.Select.MeshGroup.SortedRenderUnits; //<<변경 : Sorted 리스트 이용
for (int iUnit = 0; iUnit < renderUnits.Count; iUnit++)
{
apRenderUnit renderUnit = renderUnits[iUnit];
if (renderUnit._meshTransform != null && renderUnit._meshTransform._mesh != null)
{
if (renderUnit._meshTransform._isVisible_Default)
{
//Debug.LogError("TODO : Mouse Picking 바꿀것");
//bool isPick = apEditorUtil.IsMouseInMesh(
// mousePosGL,
// renderUnit._meshTransform._mesh,
// renderUnit.WorldMatrixOfNode.inverse
// );
bool isPick = apEditorUtil.IsMouseInRenderUnitMesh(
mousePosGL, renderUnit);
if (isPick)
{
selectedMeshTransform = renderUnit._meshTransform;
//찾았어도 계속 찾는다.
//뒤의 아이템이 "앞쪽"에 있는 것이기 때문
}
}
}
}
if (selectedMeshTransform != null)
{
//이전 버전
//>> 만약 ChildMeshGroup에 속한 거라면, Mesh Group 자체를 선택해야 한다.
//apMeshGroup parentMeshGroup = Editor.Select.MeshGroup.FindParentMeshGroupOfMeshTransform(selectedMeshTransform);
//if (parentMeshGroup == null || parentMeshGroup == Editor.Select.MeshGroup)
//{
// Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
//}
//else
//{
// apTransform_MeshGroup childMeshGroupTransform = Editor.Select.MeshGroup.FindChildMeshGroupTransform(parentMeshGroup);
// if (childMeshGroupTransform != null)
// {
// Editor.Select.SetSubMeshGroupInGroup(childMeshGroupTransform);
// }
// else
// {
// Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
// }
//}
//수정된 버전
//>> 그냥 MeshGroup Transform은 마우스로 선택 못하는 걸로 하자
Editor.Select.SetSubMeshInGroup(selectedMeshTransform);
//result = 1;
resultObj = selectedMeshTransform;
//if(prevSelectedMeshGroupTransform == Editor.Select.SubMeshGroupInGroup
// //&& prevSelectedMeshGroupTransform == Editor.Select.SubMeshGroupInGroup//<<이거 뭐야?
// )
//{
// //isSameObject = true;
// //result = apGizmos.SELECT_RESULT.SameSelected;
// result = 1;
// resultObj = Editor.Select.SubMeshGroupInGroup;
//}
//else
//{
// //isSameObject = false;
// //result = apGizmos.SELECT_RESULT.NewSelected;
// result = 1;
//}
}
else
{
Editor.Select.SetSubMeshInGroup(null);
}
Editor.RefreshControllerAndHierarchy();
//Editor.Repaint();
Editor.SetRepaint();
}
if (resultObj == null)
{
resultObj = prevSelectedMeshGroupTransform;
}
//return result;
return(apGizmos.SelectResult.Main.SetSingle(resultObj));
}
// Functions
//--------------------------------------
public void SetMeshGroup(apMeshGroup meshGroup)
{
if (meshGroup == null)
{
_childMeshGroup = null;
//ID를 반납하자
if (_childMeshGroupTransform != null)
{
//_portrait.PushUniqueID_Transform(_childMeshGroupTransform._transformUniqueID);
_portrait.PushUnusedID(apIDManager.TARGET.Transform, _childMeshGroupTransform._transformUniqueID);
_childMeshGroupTransform = null;
}
_renderUnit = null;
}
if (meshGroup != null)
{
_childMeshGroup = meshGroup;
bool resetMeshGroupTransform = false;
if (_childMeshGroupTransform == null)
{
resetMeshGroupTransform = true;
}
else if (_childMeshGroupTransform._meshGroupUniqueID != meshGroup._uniqueID)
{
//_portrait.PushUniqueID_Transform(_childMeshGroupTransform._transformUniqueID);
_portrait.PushUnusedID(apIDManager.TARGET.Transform, _childMeshGroupTransform._transformUniqueID);
_childMeshGroupTransform = null;
resetMeshGroupTransform = true;
}
if (resetMeshGroupTransform)
{
//Root는 별도의 Transform_MeshGroup을 가진다.
//새로운 ID로 Transform을 만들자
//_childMeshGroupTransform = new apTransform_MeshGroup(_portrait.MakeUniqueID_Transform());
_childMeshGroupTransform = new apTransform_MeshGroup(_portrait.MakeUniqueID(apIDManager.TARGET.Transform));
_childMeshGroupTransform._meshGroupUniqueID = meshGroup._uniqueID;
_childMeshGroupTransform._nickName = meshGroup._name;
_childMeshGroupTransform._meshGroup = meshGroup;
_childMeshGroupTransform._matrix = new apMatrix();
_childMeshGroupTransform._isVisible_Default = true;
_childMeshGroupTransform._depth = 1;
//추가
//Root Transform_MeshGroup에 해당하는 RenderUnit
_renderUnit = new apRenderUnit(_portrait, "Root");
_renderUnit.SetGroup(meshGroup, _childMeshGroupTransform, null);
_renderUnit._childRenderUnits.Add(meshGroup._rootRenderUnit);
}
else
{
_childMeshGroupTransform._meshGroup = meshGroup; //Link만 하자
if (_renderUnit == null)
{
_renderUnit = new apRenderUnit(_portrait, "Root");
_renderUnit.SetGroup(meshGroup, _childMeshGroupTransform, null);
_renderUnit._childRenderUnits.Add(meshGroup._rootRenderUnit);
}
else
{
_renderUnit._meshGroupTransform = _childMeshGroupTransform;
_renderUnit._meshGroup = meshGroup;
_renderUnit._childRenderUnits.Clear();
_renderUnit._childRenderUnits.Add(meshGroup._rootRenderUnit);
}
}
}
}
// Functions
//------------------------------------------
public void UpdateBeforeBake(apPortrait portrait, apMeshGroup mainMeshGroup, apTransform_MeshGroup mainMeshGroupTransform)
{
}
public bool _isRemapPosOffset_Initialized = false; //<<Transform과 연결후, 또는 PSD Set Layer의 값으로 부터 초기화가 되었는가
// Init
//---------------------------------------------------
public apPSDLayerData(int layerIndex, IPsdLayer psdLayer, int imageTotalWidth, int imageTotalHeight)
{
_layerIndex = layerIndex;
_name = psdLayer.Name;
_isClipping = psdLayer.IsClipping;
_isBakable = true;
//_srcPsdLayer = psdLayer;
_isClippingValid = true; //일단 가능하다고 체크
if (psdLayer.HasImage)
{
//1. 이미지 타입의 레이어
_isImageLayer = true;
_width = psdLayer.Width;
_height = psdLayer.Height;
_posOffset_Left = psdLayer.Left;
_posOffset_Top = imageTotalHeight - psdLayer.Top; //좌표계 특성상 반전하자
_posOffset_Right = psdLayer.Right;
_posOffset_Bottom = imageTotalHeight - psdLayer.Bottom;
_posOffset = new Vector2(
(float)(_posOffset_Left + _posOffset_Right) * 0.5f,
(float)(_posOffset_Top + _posOffset_Bottom) * 0.5f
);
_opacity = psdLayer.Opacity;
_transparentColor2X = new Color(0.5f, 0.5f, 0.5f, _opacity);
_colorData = new byte[_width * _height * 4]; //W x H x RGBA(4)
//_colors = new Color[_width * _height];
int subDataLength = _width * _height;
int totalDataLength = imageTotalWidth * imageTotalHeight;
byte[] colorData_R = new byte[subDataLength];
byte[] colorData_G = new byte[subDataLength];
byte[] colorData_B = new byte[subDataLength];
byte[] colorData_A = new byte[subDataLength];
byte[] colorData_Mask = new byte[subDataLength];
bool isMask = false;
for (int i = 0; i < subDataLength; i++)
{
colorData_R[i] = 0;
colorData_G[i] = 0;
colorData_B[i] = 0;
colorData_A[i] = 255;
colorData_Mask[i] = 255;
}
for (int iChannel = 0; iChannel < psdLayer.Channels.Length; iChannel++)
{
IChannel curChannel = psdLayer.Channels[iChannel];
byte[] curColorData = null;
if (curChannel.Type == ChannelType.Mask)
{
continue;
}
switch (curChannel.Type)
{
case ChannelType.Red:
curColorData = colorData_R;
break;
case ChannelType.Green:
curColorData = colorData_G;
break;
case ChannelType.Blue:
curColorData = colorData_B;
break;
case ChannelType.Alpha:
curColorData = colorData_A;
break;
case ChannelType.Mask:
//마스크는 무시한다.
curColorData = colorData_Mask;
isMask = true;
break;
}
int dataLength = curChannel.Data.Length;
if (subDataLength != dataLength)
{
//저장되었어야할 데이터와 실제 데이터가 다르다.
bool isError = true;
if (curChannel.Type == ChannelType.Mask)
{
isMask = false;
//만약 -> Mask의 경우
//이미지 전체가 들어올 수는 있다.
//확장된 데이터 사이즈와 비교를 하자
if (dataLength == totalDataLength)
{
isError = false;
isMask = true;
//데이터가 Height가 거꾸로 되어있다.
//X, Y의 오프셋을 적용해야한다.
//Debug.Log("Mask Image : Total : " + dataLength + "( " + imageTotalWidth + " x " + imageTotalHeight + " )");
//Debug.Log("X : " + _posOffset_Left + " ~ " + _posOffset_Right);
//Debug.Log("Y : " + +_posOffset_Top + " ~ " + _posOffset_Bottom);
}
}
if (isError)
{
Debug.LogError("Data Length is not correct : " + _name + " [ Channel : " + curChannel.Type + " ]");
//Debug.LogError("Data Size : " + curChannel.Data.Length + " (Expected : " + totalDataLength + " / Sub : " + subDataLength + ")");
//Debug.Log("Mask Image : Total : " + dataLength + "( " + imageTotalWidth + " x " + imageTotalHeight + " )");
//Debug.Log("X : " + _posOffset_Left + " ~ " + _posOffset_Right);
//Debug.Log("Y : " + +_posOffset_Top + " ~ " + _posOffset_Bottom);
continue;
}
}
else
{
//칼라값을 복사하자
Array.Copy(curChannel.Data, curColorData, dataLength);
}
}
//이제 마지막으로 byte 배열을 만들고 Texture로 구성하자
int iMainColor = 0;
int iX = 0;
int iY = 0;
if (!isMask)
{
//Debug.Log("Image : " + layerIndex + " [ No Mask ]");
//마스크가 없는 경우
for (int iColor = 0; iColor < subDataLength; iColor++)
{
//iColor = y * Width + x
//RevYColor = ((Height - Y) * Width) + X
//iMainColor = iColor * 4;
iY = iColor / _width;
iX = iColor % _width;
iMainColor = ((((_height - 1) - iY) * _width) + iX) * 4;
_colorData[iMainColor + 0] = colorData_R[iColor];
_colorData[iMainColor + 1] = colorData_G[iColor];
_colorData[iMainColor + 2] = colorData_B[iColor];
_colorData[iMainColor + 3] = colorData_A[iColor];
//_colors[iColor] = ByteToColor(
// _colorData[iMainColor + 0],
// _colorData[iMainColor + 1],
// _colorData[iMainColor + 2],
// _colorData[iMainColor + 3]
// );
}
}
else
{
//Debug.Log("Image : " + layerIndex + " [ Mask ]");
//마스크가 있는 경우
for (int iColor = 0; iColor < subDataLength; iColor++)
{
//iMainColor = iColor * 4;
//iColor = y * Width + x
//RevYColor = ((Height - Y) * Width) + X
//iMainColor = iColor * 4;
iY = iColor / _width;
iX = iColor % _width;
iMainColor = ((((_height - 1) - iY) * _width) + iX) * 4;
_colorData[iMainColor + 0] = GetMaskedColor(colorData_R[iColor], colorData_Mask[iColor]);
_colorData[iMainColor + 1] = GetMaskedColor(colorData_G[iColor], colorData_Mask[iColor]);
_colorData[iMainColor + 2] = GetMaskedColor(colorData_B[iColor], colorData_Mask[iColor]);
_colorData[iMainColor + 3] = GetMaskedColor(colorData_A[iColor], colorData_Mask[iColor]);
//_colors[iColor] = ByteToColor(
// _colorData[iMainColor + 0],
// _colorData[iMainColor + 1],
// _colorData[iMainColor + 2],
// _colorData[iMainColor + 3]
// );
}
}
_image = new Texture2D(_width, _height, TextureFormat.RGBA32, false);
//_image.SetPixels(_colors);
_image.LoadRawTextureData(_colorData);
_image.wrapMode = TextureWrapMode.Clamp;
_image.Apply();
}
else
{
_isImageLayer = false;
_image = null;
_width = 0;
_height = 0;
_colorData = null;
_width = psdLayer.Width;
_height = psdLayer.Height;
_posOffset_Left = psdLayer.Left;
_posOffset_Top = imageTotalHeight - psdLayer.Top; //좌표계 특성상 반전하자
_posOffset_Right = psdLayer.Right;
_posOffset_Bottom = imageTotalHeight - psdLayer.Bottom;
_posOffset = new Vector2(
(float)(_posOffset_Left + _posOffset_Right) * 0.5f,
(float)(_posOffset_Top + _posOffset_Bottom) * 0.5f
);
_opacity = 1.0f;
_transparentColor2X = Color.black;
}
_posOffsetLocal = _posOffset;
_parentLayer = null;
_childLayers = null;
_isRemapSelected = false;
_remap_TransformID = -1;
_remap_MeshTransform = null;
_remap_MeshGroupTransform = null;
_remapPosOffsetDelta_X = 0;
_remapPosOffsetDelta_Y = 0;
_isRemapPosOffset_Initialized = false;
//추가 : GUI를 위해서 랜덤한 색상을 정하자
MakeRandomGUIColor();
}
private static void MakeSubUnits(apMeshGroup targetMeshGroup,
List <apRetargetSubUnit> transforms_All,
List <apRetargetSubUnit> transforms_Root,
List <apRetargetSubUnit> bones_All,
List <apRetargetSubUnit> bones_Root)
{
int unitID = 0;
if (targetMeshGroup._childMeshTransforms != null)
{
for (int i = 0; i < targetMeshGroup._childMeshTransforms.Count; i++)
{
apTransform_Mesh meshTransform = targetMeshGroup._childMeshTransforms[i];
apRetargetSubUnit newSubUnit = new apRetargetSubUnit();
newSubUnit.SetSubData(unitID, meshTransform, null, null, null);
unitID++;
transforms_All.Add(newSubUnit);
transforms_Root.Add(newSubUnit);
}
}
if (targetMeshGroup._childMeshGroupTransforms != null)
{
for (int i = 0; i < targetMeshGroup._childMeshGroupTransforms.Count; i++)
{
apTransform_MeshGroup meshGroupTransform = targetMeshGroup._childMeshGroupTransforms[i];
//재귀 호출로 ChildMeshGroup의 SubUnit을 만들어주자
unitID = MakeSubUnitsFromMeshGroupTransformRecursive(targetMeshGroup, meshGroupTransform,
unitID,
transforms_All, transforms_Root,
null);
}
}
//Sort를 다시 하자
for (int i = 0; i < transforms_All.Count; i++)
{
apRetargetSubUnit subUnit = transforms_All[i];
int sortIndex = -1;
if (subUnit._type == apRetargetSubUnit.TYPE.MeshTransform)
{
sortIndex = targetMeshGroup._renderUnits_All.FindIndex(delegate(apRenderUnit a)
{
if (a._meshTransform == null)
{
return(false);
}
return(a._meshTransform._transformUniqueID == subUnit._uniqueID);
});
}
else if (subUnit._type == apRetargetSubUnit.TYPE.MeshGroupTransform)
{
sortIndex = targetMeshGroup._renderUnits_All.FindIndex(delegate(apRenderUnit a)
{
if (a._meshGroupTransform == null)
{
return(false);
}
return(a._meshGroupTransform._transformUniqueID == subUnit._uniqueID);
});
}
subUnit._sortIndex = sortIndex;
}
transforms_All.Sort(delegate(apRetargetSubUnit a, apRetargetSubUnit b)
{
return(b._sortIndex - a._sortIndex);
});
//Bone도 넣자
//<BONE_EDIT>
//if(targetMeshGroup._boneList_Root.Count > 0)
//{
// for (int i = 0; i < targetMeshGroup._boneList_Root.Count; i++)
// {
// unitID = MakeSubUnitsFromBonesRecursive(targetMeshGroup,
// targetMeshGroup._boneList_Root[i],
// unitID, bones_All, bones_Root, null);
// }
//}
//>> Bone Set으로 변경
if (targetMeshGroup._boneListSets.Count > 0)
{
apMeshGroup.BoneListSet boneSet = null;
for (int iSet = 0; iSet < targetMeshGroup._boneListSets.Count; iSet++)
{
boneSet = targetMeshGroup._boneListSets[iSet];
for (int iRoot = 0; iRoot < boneSet._bones_Root.Count; iRoot++)
{
unitID = MakeSubUnitsFromBonesRecursive(
boneSet._bones_Root[iRoot],
unitID, bones_All, bones_Root, null);
}
}
}
//Sort를 다시 하자
for (int i = 0; i < bones_All.Count; i++)
{
apRetargetSubUnit subUnit = bones_All[i];
//<BONE_EDIT>
//subUnit._sortIndex = targetMeshGroup._boneList_All.FindIndex(delegate (apBone a)
//{
// return a._uniqueID == subUnit._uniqueID;
//});
//>>Bone Set을 이용
subUnit._sortIndex = -1;
apMeshGroup.BoneListSet boneSet = null;
int startIndex = 0;
for (int iSet = 0; iSet < targetMeshGroup._boneListSets.Count; iSet++)
{
boneSet = targetMeshGroup._boneListSets[iSet];
//현재의 Bone List에 있는지 확인
int resultIndex = boneSet._bones_All.FindIndex(delegate(apBone a)
{
return(a._uniqueID == subUnit._uniqueID);
});
if (resultIndex >= 0 && resultIndex < boneSet._bones_All.Count)
{
//찾았다.
subUnit._sortIndex = startIndex + resultIndex;
break;
}
else
{
//업다면 기본 인덱스 증가
startIndex += boneSet._bones_All.Count;
}
}
}
bones_All.Sort(delegate(apRetargetSubUnit a, apRetargetSubUnit b)
{
return(a._sortIndex - b._sortIndex);
});
}
