// Init
//----------------------------------------------
public apRetargetSubUnit()
{
_isImported = false;
_targetMeshTransform = null;
_targetMeshGroupTransform = null;
_targetBone = null;
}
public apModifierParamSetGroupVertWeight GetWeightVertexData(apTransform_Mesh meshTransform)
{
return(_calculatedWeightedVertexList.Find(delegate(apModifierParamSetGroupVertWeight a)
{
return a._meshTransform_ID == meshTransform._transformUniqueID;
}));
}
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;
}
}
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_Mesh meshTransform)
{
return(_layers.Find(delegate(apPSDSetLayer a)
{
return a._transformID == meshTransform._transformUniqueID && a._isImageLayer;
}));
}
public bool IsSubMeshInGroup(apTransform_Mesh subMeshTransform)
{
if (subMeshTransform == null)
{
return(false);
}
return(_syncTransform_Mesh.Contains(subMeshTransform));
}
public void LinkMeshTransform(apTransform_Mesh meshTransform)
{
_meshTransform = meshTransform;
if (_meshTransform == null)
{
_meshTransform_ID = -1;
}
RefreshVertexList();
}
// Init
//--------------------------------------------------------------------
public void Init(apEditor editor,
object loadKey,
apMeshGroup srcMeshGroup,
apTransform_Mesh srcMeshTransform,
FUNC_SELECT_MESH_TF_COPY funcResult)
{
_editor = editor;
_loadKey = loadKey;
_meshGroup = srcMeshGroup;
_funcResult = funcResult;
_srcMeshTransform = srcMeshTransform;
//타겟을 검색하자
_meshTransforms.Clear();
_img_Mesh = _editor.ImageSet.Get(apImageSet.PRESET.Hierarchy_Mesh);
_img_FoldDown = _editor.ImageSet.Get(apImageSet.PRESET.Hierarchy_FoldDown);
//대상이 되는 데이터를 가져온다.
for (int i = 0; i < _meshGroup._renderUnits_All.Count; i++)
{
apRenderUnit renderUnit = _meshGroup._renderUnits_All[i];
if (renderUnit._meshTransform == null || renderUnit._meshTransform == _srcMeshTransform)
{
continue;
}
if (!_meshTransforms.Contains(renderUnit._meshTransform))
{
_meshTransforms.Add(renderUnit._meshTransform);
}
}
_meshTransforms.Reverse();
if (_copiedProperties == null)
{
_copiedProperties = new Dictionary <COPIED_PROPERTIES, bool>();
}
_copiedProperties.Clear();
_copiedProperties.Add(COPIED_PROPERTIES.DefaultColor, false);
_copiedProperties.Add(COPIED_PROPERTIES.ShaderType, false);
_copiedProperties.Add(COPIED_PROPERTIES.CustomShader, false);
_copiedProperties.Add(COPIED_PROPERTIES.RenderTextureSize, false);
_copiedProperties.Add(COPIED_PROPERTIES.TwoSides, false);
_copiedProperties.Add(COPIED_PROPERTIES.ShadowSettings, false);
_copiedProperties.Add(COPIED_PROPERTIES.MaterialSet, false);
_copiedProperties.Add(COPIED_PROPERTIES.MaterialProperties, false);
}
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 IsContainMeshTransform(apTransform_Mesh meshTransform)
{
if (meshTransform == null)
{
return(false);
}
return(_meshData.Exists(delegate(apModifiedMesh a)
{
return a._isMeshTransform && a._transform_Mesh == meshTransform;
}));
}
/// <summary>
/// 처리를 도와주는 함수. MeshTransform의 Parent MeshGroup을 검색한다.
/// </summary>
/// <param name="meshTransform"></param>
/// <returns></returns>
private apMeshGroup GetParentMeshGroupOfMeshTransform(apTransform_Mesh meshTransform)
{
for (int i = 0; i < _portrait._meshGroups.Count; i++)
{
if (_portrait._meshGroups[i]._childMeshTransforms.Contains(meshTransform))
{
//찾았다!
return(_portrait._meshGroups[i]);
}
}
return(null);
}
// 비교 관련
//------------------------------------------
public bool IsContains_MeshTransform(apMeshGroup meshGroup, apTransform_Mesh meshTransform, apMesh mesh)
{
if (_meshGroupUniqueID_Modifier == meshGroup._uniqueID &&
_transformUniqueID == meshTransform._transformUniqueID &&
_transformUniqueID >= 0 &&
_meshUniqueID == mesh._uniqueID &&
_isMeshTransform
)
{
return(true);
}
return(false);
}
public apModifierParamSetGroupVertWeight(apTransform_Mesh meshTransform)
{
_meshTransform = meshTransform;
_meshTransform_ID = _meshTransform._transformUniqueID;
_weightedVerts.Clear();
if (_meshTransform._mesh != null)
{
List <apVertex> verts = _meshTransform._mesh._vertexData;
for (int i = 0; i < verts.Count; i++)
{
_weightedVerts.Add(new WeightedVertex(verts[i]._uniqueID, i));
}
}
}
// 추가
//--------------------------------------------------------------------------------
/// <summary>
/// ParamSetGroup 내의 모든 ParamSet에서 MeshTransform을 포함한 ModMesh를 모두 삭제한다.
/// 주의 메세지를 꼭 출력할 것
/// </summary>
/// <param name="meshTransform"></param>
public void RemoveModifierMeshes(apTransform_Mesh meshTransform)
{
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_MeshTransform(_parentModifier._meshGroup, meshTransform, meshTransform._mesh));
});
if (nRemoved > 0)
{
//Debug.LogError("Remove ModMesh [RemoveModifierMeshes / MeshTransform] : " + meshTransform._nickName + " / " + nRemoved);
}
}
}
//public void SetTarget_Bone(int boneID)
//{
// _boneUniqueID = boneID;
//}
#region [미사용 코드] 타입에 따른 초기화는 유연성이 떨어져서 패스.
//public void Init_VertexMorph(int meshGroupID, int meshTransformID, int meshID)
//{
// _targetType = TARGET_TYPE.VertexWithMeshTransform;
// _meshGroupUniqueID = meshGroupID;
// _transformUniqueID = meshTransformID;
// _meshUniqueID = meshID;
// _boneUniqueID = -1;
//}
//public void Init_MeshTransform(int meshGroupID, int meshTransformID, int meshID)
//{
// _targetType = TARGET_TYPE.MeshTransformOnly;
// _meshGroupUniqueID = meshGroupID;
// _transformUniqueID = meshTransformID;
// _meshUniqueID = meshID;
// _boneUniqueID = -1;
//}
//public void Init_MeshGroupTransform(int meshGroupID, int meshGroupTransformID)
//{
// _targetType = TARGET_TYPE.MeshGroupTransformOnly;
// _meshGroupUniqueID = meshGroupID;
// _transformUniqueID = meshGroupTransformID;
// _meshUniqueID = -1;
// _boneUniqueID = -1;
//}
//public void Init_BoneTransform(int meshGroupID, int boneID)
//{
// _targetType = TARGET_TYPE.Bone;
// _meshGroupUniqueID = meshGroupID;
// _transformUniqueID = -1;
// _meshUniqueID = -1;
// _boneUniqueID = boneID;
//}
#endregion
// Init - ID에 맞게 세팅
//--------------------------------------------------------
//이건 날립니더
//public void Link_VertexMorph(apMeshGroup meshGroup, apTransform_Mesh meshTransform, apRenderUnit renderUnit)
//{
// _meshGroup = meshGroup;
// _transform_Mesh = meshTransform;
// _renderUnit = renderUnit;
// //RefreshVertices();
//}
/// <summary>
/// MeshTransform과 ModMesh를 연결한다.
/// </summary>
/// <param name="meshGroupOfMod">Modifier가 속한 MeshGroup</param>
///<param name="meshGroupOfTransform">Transform이 속한 MeshGroup</param>
public void Link_MeshTransform(apMeshGroup meshGroupOfMod, apMeshGroup meshGroupOfTransform, apTransform_Mesh meshTransform, apRenderUnit renderUnit, apPortrait portrait)
{
_meshGroupOfModifier = meshGroupOfMod;
_meshGroupOfTransform = meshGroupOfTransform;
_transform_Mesh = meshTransform;
_renderUnit = renderUnit;
if (_isUsePhysicParam)
{
if (_physicMeshParam == null)
{
_physicMeshParam = new apPhysicsMeshParam();
}
_physicMeshParam.Link(portrait);
}
//Debug.Log("ModMesh Link RenderUnit");
RefreshModifiedValues(meshGroupOfMod._parentPortrait);
}
public void AddClippedChildMesh(apTransform_Mesh meshTransform, apRenderUnit renderUnit)
{
_isClipping_Parent = true;
if (_clipChildMeshes.Exists(delegate(ClipMeshSet a)
{
return(a._meshTransform == meshTransform);
}))
{
//겹친다면 Pass
SortClipMeshTransforms();
return;
}
int clippIndex = _clipChildMeshes.Count;
_clipChildMeshes.Add(new ClipMeshSet(meshTransform, renderUnit));
meshTransform._isClipping_Child = true;
meshTransform._clipIndexFromParent = clippIndex;
#region [미사용 코드]
//_clipChildMeshTransformIDs.Add(meshTransform._transformUniqueID);
//_clipChildMeshTransforms.Add(meshTransform);
//_clipChildRenderUnits.Add(renderUnit);
//이전 코드 : 3개 고정
//for (int i = 0; i < 3; i++)
//{
// if(_clipChildMeshTransforms[i] == null)
// {
// _clipChildMeshTransforms[i] = meshTransform;
// _clipChildMeshTransformIDs[i] = meshTransform._transformUniqueID;
// _clipChildRenderUnits[i] = renderUnit;
// break;
// }
//}
#endregion
SortClipMeshTransforms();
}
// Show Window
//--------------------------------------------------------------
public static object ShowDialog(apEditor editor,
apMeshGroup srcMeshGroup,
apTransform_Mesh srcMeshTransform,
FUNC_SELECT_MESH_TF_COPY funcResult)
{
CloseDialog();
if (editor == null || editor._portrait == null)
{
return(null);
}
EditorWindow curWindow = EditorWindow.GetWindow(typeof(apDialog_SelectMeshTransformsToCopy), true, "Select Child Meshes", true);
apDialog_SelectMeshTransformsToCopy curTool = curWindow as apDialog_SelectMeshTransformsToCopy;
object loadKey = new object();
if (curTool != null && curTool != s_window)
{
int width = 500;
int height = 600;
s_window = curTool;
s_window.position = new Rect((editor.position.xMin + editor.position.xMax) / 2 - (width / 2),
(editor.position.yMin + editor.position.yMax) / 2 - (height / 2),
width, height);
s_window.Init(editor, loadKey, srcMeshGroup, srcMeshTransform, funcResult);
return(loadKey);
}
else
{
return(null);
}
}
// GUI
//--------------------------------------------------------------------
void OnGUI()
{
int width = (int)position.width;
int height = (int)position.height;
if (_editor == null || _funcResult == null)
{
return;
}
Color prevColor = GUI.backgroundColor;
GUI.backgroundColor = new Color(0.9f, 0.9f, 0.9f);
//Top : (탭) 또는 없음
int yOffset = 10;
int height_Properties = 80;
int height_Bottom = 70;
int height_Main = height - (height_Properties + height_Bottom + 60);
GUI.Box(new Rect(0, yOffset, width, height_Main), "");
GUI.backgroundColor = prevColor;
EditorGUILayout.BeginVertical();
//Request Type이 "Mesh" 또는 "ChildTransform"이라면 탭이 없다.
//Request Type이 "MeshAndMeshGroups"라면 탭이 있다.
//1. Tab
GUILayout.Space(5);
int width_BtnHalf = (width - 10) / 2 - 2;
string strCategory = _meshGroup._name;
GUILayout.Space(5);
GUIStyle guiStyle_None = new GUIStyle(GUIStyle.none);
guiStyle_None.normal.textColor = GUI.skin.label.normal.textColor;
GUIStyle guiStyle_Selected = new GUIStyle(GUIStyle.none);
if (EditorGUIUtility.isProSkin)
{
guiStyle_Selected.normal.textColor = Color.cyan;
}
else
{
guiStyle_Selected.normal.textColor = Color.white;
}
int height_ListItem = 20;
string strSelected = _editor.GetText(TEXT.DLG_Selected);
string strNotSelected = _editor.GetText(TEXT.DLG_NotSelected);
_scrollList = EditorGUILayout.BeginScrollView(_scrollList, GUILayout.Width(width), GUILayout.Height(height_Main));
EditorGUILayout.BeginVertical(GUILayout.Width(width - 24));
GUILayout.Button(new GUIContent(strCategory, _img_FoldDown), guiStyle_None, GUILayout.Height(height_ListItem)); //<투명 버튼
//리스트 방식 : 아이콘 + 이름 / Selected 버튼 (토글)
int width_SelectBtn = 100;
int width_Label = width - (width_SelectBtn + 42);
bool isSelected = false;
//MeshTransform을 출력하자
apTransform_Mesh curMeshTF = null;
for (int i = 0; i < _meshTransforms.Count; i++)
{
curMeshTF = _meshTransforms[i];
isSelected = _selectedMeshTransforms.Contains(curMeshTF);
EditorGUILayout.BeginHorizontal(GUILayout.Height(height_ListItem));
GUILayout.Space(10);
EditorGUILayout.LabelField(new GUIContent(" " + curMeshTF._nickName, _img_Mesh), GUILayout.Width(width_Label), GUILayout.Height(height_ListItem));
if (apEditorUtil.ToggledButton_2Side(strSelected, strNotSelected, isSelected, true, width_SelectBtn, height_ListItem))
{
if (isSelected)
{
_selectedMeshTransforms.Remove(curMeshTF);
}
else
{
_selectedMeshTransforms.Add(curMeshTF);
}
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(2);
}
GUILayout.Space(height + 20);
EditorGUILayout.EndVertical();
EditorGUILayout.EndScrollView();
EditorGUILayout.EndVertical();
GUILayout.Space(5);
//복사할 속성들을 토글한다.
//두줄로 적자
//"Select Properties to copy"
EditorGUILayout.LabelField(_editor.GetText(TEXT.SelectPropertiesToCopy));
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal(GUILayout.Width(width), GUILayout.Height(height_Properties));
GUILayout.Space(5);
//왼쪽 줄
EditorGUILayout.BeginVertical(GUILayout.Width(width_BtnHalf), GUILayout.Height(height_Properties));
DrawPropertyToggle(COPIED_PROPERTIES.DefaultColor, _editor.GetText(TEXT.DefaultColor), width_BtnHalf); //"Default Color"
DrawPropertyToggle(COPIED_PROPERTIES.ShaderType, _editor.GetText(TEXT.BlendingType), width_BtnHalf); //"Blending Type"
DrawPropertyToggle(COPIED_PROPERTIES.CustomShader, _editor.GetText(TEXT.CustomShader), width_BtnHalf); //"Custom Shader"
DrawPropertyToggle(COPIED_PROPERTIES.RenderTextureSize, _editor.GetText(TEXT.RenderTextureSize), width_BtnHalf); //"Render Texture Size"
EditorGUILayout.EndVertical();
GUILayout.Space(5);
//오른쪽 줄
EditorGUILayout.BeginVertical(GUILayout.Width(width_BtnHalf), GUILayout.Height(height_Properties));
DrawPropertyToggle(COPIED_PROPERTIES.TwoSides, _editor.GetText(TEXT.TwoSidedMesh), width_BtnHalf); //"2-Sides Rendering"
DrawPropertyToggle(COPIED_PROPERTIES.ShadowSettings, _editor.GetText(TEXT.ShadowSettings), width_BtnHalf); //"Shadow Settings"
DrawPropertyToggle(COPIED_PROPERTIES.MaterialSet, _editor.GetText(TEXT.MaterialSet), width_BtnHalf); //"Material Set"
DrawPropertyToggle(COPIED_PROPERTIES.MaterialProperties, _editor.GetText(TEXT.CustomMaterialProperties), width_BtnHalf); //"Custom Material Properties"
EditorGUILayout.EndVertical();
EditorGUILayout.EndHorizontal();
GUILayout.Space(10);
//첫줄에는 Select All / Deselect All
//둘째줄에는 Add 또는 Apply (인자로 받음) / Close
EditorGUILayout.BeginHorizontal(GUILayout.Height(22));
GUILayout.Space(5);
if (GUILayout.Button(_editor.GetText(TEXT.DLG_SelectAll), GUILayout.Width(width_BtnHalf), GUILayout.Height(22)))
{
//Select All
for (int i = 0; i < _meshTransforms.Count; i++)
{
curMeshTF = _meshTransforms[i];
if (!_selectedMeshTransforms.Contains(curMeshTF))
{
_selectedMeshTransforms.Add(curMeshTF);
}
}
}
if (GUILayout.Button(_editor.GetText(TEXT.DLG_DeselectAll), GUILayout.Width(width_BtnHalf), GUILayout.Height(22)))
{
//Deselect All
_selectedMeshTransforms.Clear();
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(5);
EditorGUILayout.BeginHorizontal(GUILayout.Height(30));
GUILayout.Space(5);
bool isClose = false;
if (GUILayout.Button(_editor.GetText(TEXT.DLG_Apply), GUILayout.Width(width_BtnHalf), GUILayout.Height(30)))
{
_funcResult(true, _loadKey, _srcMeshTransform, _selectedMeshTransforms, GetCopiedPropertyList());
isClose = true;
}
if (GUILayout.Button(_editor.GetText(TEXT.DLG_Close), GUILayout.Width(width_BtnHalf), GUILayout.Height(30))) //"Close"
{
_funcResult(false, _loadKey, null, null, null);
isClose = true;
}
EditorGUILayout.EndHorizontal();
if (isClose)
{
CloseDialog();
}
}
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();
}
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));
}
public RenderUnitTransformMeshSet(apTransform_Mesh meshTransform, apRenderUnit renderUnit)
{
_meshTransform = meshTransform;
_renderUnit = renderUnit;
}
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);
});
}
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>
/// 재활용을 위해 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 ClipMeshSet(apTransform_Mesh meshTransform, apRenderUnit renderUnit)
{
_transformID = meshTransform._transformUniqueID;
_meshTransform = meshTransform;
_renderUnit = renderUnit;
}
// 중요!
//Mesh Transform / MeshGroup Transform을 각각의 ParamSet에 넣어준다.
//Modifier 조건에 맞게 처리한다.
private bool AddMeshTransformToParamSet(apModifierParamSet paramSet, apTransform_Mesh meshTransform)
{
//if(_parentModifier.ModifiedTargetType != apModifiedMesh.TARGET_TYPE.MeshTransformOnly &&
// _parentModifier.ModifiedTargetType != apModifiedMesh.TARGET_TYPE.VertexWithMeshTransform)
//{
// //추가할 수 없다.
// return false;
//}
if (!_parentModifier.IsTarget_MeshTransform)
{
return(false);
}
bool isExist = paramSet._meshData.Exists(delegate(apModifiedMesh a)
{
return(a.IsContains_MeshTransform(_parentModifier._meshGroup, meshTransform, meshTransform._mesh));
});
if (!isExist)
{
apRenderUnit targetRenderUnit = _parentModifier._meshGroup.GetRenderUnit(meshTransform);
if (targetRenderUnit != null)
{
apMeshGroup parentMeshGroupOfTransform = GetParentMeshGroupOfMeshTransform(meshTransform);
if (parentMeshGroupOfTransform == null)
{
//Parent MeshGroup이 없네염
return(false);
}
apModifiedMesh modMesh = new apModifiedMesh();
modMesh.Init(_parentModifier._meshGroup._uniqueID, parentMeshGroupOfTransform._uniqueID, _parentModifier.ModifiedValueType);
modMesh.SetTarget_MeshTransform(meshTransform._transformUniqueID, meshTransform._mesh._uniqueID, meshTransform._meshColor2X_Default, meshTransform._isVisible_Default);
modMesh.Link_MeshTransform(_parentModifier._meshGroup, parentMeshGroupOfTransform, meshTransform, targetRenderUnit, _portrait);
#region [미사용 코드] 확장성 있는 코드로 변경했다.
//if (_parentModifier.ModifiedTargetType == apModifiedMesh.TARGET_TYPE.VertexWithMeshTransform)
//{
// modMesh.Init_VertexMorph(_parentModifier._meshGroup._uniqueID,
// meshTransform._transformUniqueID,
// meshTransform._mesh._uniqueID);
// modMesh.Link_VertexMorph(_parentModifier._meshGroup, meshTransform, targetRenderUnit);
//}
//else if (_parentModifier.ModifiedTargetType == apModifiedMesh.TARGET_TYPE.MeshTransformOnly)
//{
// modMesh.Init_MeshTransform(_parentModifier._meshGroup._uniqueID,
// meshTransform._transformUniqueID,
// meshTransform._mesh._uniqueID);
// modMesh.Link_MeshTransform(_parentModifier._meshGroup, meshTransform, targetRenderUnit);
//}
#endregion
paramSet._meshData.Add(modMesh);
}
}
return(!isExist);
}
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);
}
/// <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);
}
// Get / Set
//-------------------------------------------------
public bool IsMeshTransformContain(apTransform_Mesh meshTransform)
{
return(_syncTransform_Mesh.Contains(meshTransform));
}
