public MeshBaker(Model model, List <MeshAnimation> animations, Studio studio, string sIndex, string parentFolderPath)
: base(model, studio, sIndex, parentFolderPath)
{
this.animations = animations;
meshModel = model as MeshModel;
if (studio.shadow.type == ShadowType.Simple && studio.shadow.simple.isDynamicScale)
{
simpleShadowBaseScale = studio.shadow.obj.transform.localScale;
}
stateMachine = new StateMachine <BakingState>();
stateMachine.AddState(BakingState.Initialize, OnInitialize);
stateMachine.AddState(BakingState.BeginAnimation, OnBeginAnimation);
stateMachine.AddState(BakingState.BeginView, OnBeginView);
stateMachine.AddState(BakingState.BeginFrame, OnBeginFrame);
stateMachine.AddState(BakingState.CaptureFrame, OnCaptureFrame);
stateMachine.AddState(BakingState.EndFrame, OnEndFrame);
stateMachine.AddState(BakingState.EndView, OnEndView);
stateMachine.AddState(BakingState.EndAnimation, OnEndAnimation);
stateMachine.AddState(BakingState.Finalize, OnFinalize);
stateMachine.ChangeState(BakingState.Initialize);
}
public static void ScaleMatteField(MeshModel model, GameObject fieldObj, LightProperty lit)
{
if (model == null || model.mainRenderer == null || fieldObj == null || lit == null)
{
return;
}
Renderer fieldRenderer = fieldObj.GetComponent <Renderer>();
if (fieldRenderer == null)
{
return;
}
float tan = Mathf.Tan(lit.com.transform.rotation.eulerAngles.x * Mathf.Deg2Rad);
Vector3 modelSize = model.mainRenderer.bounds.size;
float modelHalfWidth = Mathf.Max(modelSize.x, modelSize.z) / 2;
float fieldWidth = (modelSize.y / tan + modelHalfWidth) * 2;
fieldObj.transform.localScale = Vector3.one; // important
fieldObj.transform.localScale = new Vector3
(
fieldWidth / fieldRenderer.bounds.size.x,
1f,
fieldWidth / fieldRenderer.bounds.size.z
);
}
private bool DrawFixToGroundField(MeshModel model, out bool isChanged)
{
EditorGUI.BeginChangeCheck();
bool isFixingToGround = EditorGUILayout.Toggle(new GUIContent("Fix to Ground",
"animates on ground, preventing from floating"), model.isFixingToGround);
isChanged = EditorGUI.EndChangeCheck();
return(isFixingToGround);
}
private bool DrawFixToOriginField(MeshModel model, out bool isChanged)
{
EditorGUI.BeginChangeCheck();
bool isFixingToOrigin = EditorGUILayout.Toggle(new GUIContent("Fix to Origin",
"animates in place"), model.isFixingToOrigin);
isChanged = EditorGUI.EndChangeCheck();
return(isFixingToOrigin);
}
private PivotType DrawPivotTypeField(MeshModel model, out bool isChanged)
{
EditorGUI.BeginChangeCheck();
PivotType pivotType = (PivotType)EditorGUILayout.EnumPopup(new GUIContent("Pivot Type",
"type of the root object's world position"), model.pivotType);
isChanged = EditorGUI.EndChangeCheck();
return(pivotType);
}
public MeshSampler(Model model, MeshAnimation animation, Studio studio) : base(model, studio)
{
this.animation = animation;
meshModel = model as MeshModel;
if (studio.shadow.type == ShadowType.Simple && studio.shadow.simple.isDynamicScale)
{
modelBaseSize = model.GetSize();
simpleShadowBaseScale = studio.shadow.obj.transform.localScale;
}
}
public StaticBaker(Model model, Studio studio, string sIndex, string parentFolderPath)
: base(model, studio, sIndex, parentFolderPath)
{
meshModel = model as MeshModel;
stateMachine = new StateMachine <BakingState>();
stateMachine.AddState(BakingState.Initialize, OnInitialize);
stateMachine.AddState(BakingState.BeginView, OnBeginView);
stateMachine.AddState(BakingState.CaptureFrame, OnCaptureFrame);
stateMachine.AddState(BakingState.EndView, OnEndView);
stateMachine.AddState(BakingState.Finalize, OnFinalize);
stateMachine.ChangeState(BakingState.Initialize);
}
public static void ScaleSimpleShadowDynamically(Vector3 modelBaseSize, Vector3 simpleShadowBaseScale, MeshModel meshModel, Studio studio)
{
Vector3 modelCurrentSize = meshModel.GetSize();
float xScaleRatio = modelBaseSize.x / modelCurrentSize.x;
float zScaleRatio = modelBaseSize.z / modelCurrentSize.z;
Debug.Assert(xScaleRatio > 0f && zScaleRatio > 0f);
Transform shadowTransform = studio.shadow.obj.transform;
shadowTransform.localScale = simpleShadowBaseScale;
shadowTransform.localScale = new Vector3
(
shadowTransform.localScale.x * xScaleRatio,
1.0f,
shadowTransform.localScale.z * zScaleRatio
);
}
void OnEnable()
{
model = target as MeshModel;
animReorderableList = new UnityEditorInternal.ReorderableList(serializedObject, serializedObject.FindProperty("animations"))
{
drawHeaderCallback = (Rect rect) =>
{
EditorGUI.LabelField(rect, new GUIContent("Animations", "animation list to bake"));
},
drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
{
SerializedProperty element = animReorderableList.serializedProperty.GetArrayElementAtIndex(index);
rect.y += 2;
const float LEFT_MARGIN = 50;
float rectWidth = rect.width - LEFT_MARGIN;
float popupWidth = rect.width * 0.4f;
const float CHECKBOX_WIDTH = 15;
SerializedProperty clipProperty = element.FindPropertyRelative("clip");
float animClipWidth = rectWidth - popupWidth - CHECKBOX_WIDTH;
EditorGUI.BeginChangeCheck();
EditorGUI.PropertyField(
new Rect(rect.x + LEFT_MARGIN, rect.y, animClipWidth, EditorGUIUtility.singleLineHeight),
clipProperty, GUIContent.none);
if (EditorGUI.EndChangeCheck())
{
model.animations[index].selectedFrames.Clear();
}
if (model.referenceController != null && refStateMachine != null && refStateMachine.states.Length > 0 && clipProperty.objectReferenceValue != null)
{
string[] stateNames = new string[refStateMachine.states.Length];
for (int i = 0; i < refStateMachine.states.Length; ++i)
{
stateNames[i] = refStateMachine.states[i].state.name;
}
SerializedProperty stateIndexProperty = element.FindPropertyRelative("stateIndex");
stateIndexProperty.intValue =
EditorGUI.Popup(new Rect(rect.x + LEFT_MARGIN + animClipWidth + 5, rect.y, popupWidth - CHECKBOX_WIDTH - 10, EditorGUIUtility.singleLineHeight),
stateIndexProperty.intValue, stateNames);
SerializedProperty stateNameProperty = element.FindPropertyRelative("stateName");
if (stateNames.Length > stateIndexProperty.intValue)
{
stateNameProperty.stringValue = stateNames[stateIndexProperty.intValue];
}
}
SerializedProperty loopingProperty = element.FindPropertyRelative("isLooping");
loopingProperty.boolValue =
GUI.Toggle(new Rect(rect.x + rect.width - CHECKBOX_WIDTH - 10, rect.y, CHECKBOX_WIDTH + 10, EditorGUIUtility.singleLineHeight),
loopingProperty.boolValue, new GUIContent(LoopMarkTexture, "generates looping animation clip"), GUI.skin.button);
},
onAddCallback = (UnityEditorInternal.ReorderableList l) => {
var index = l.serializedProperty.arraySize;
l.serializedProperty.arraySize++;
SerializedProperty element = l.serializedProperty.GetArrayElementAtIndex(index);
element.FindPropertyRelative("clip").objectReferenceValue = null;
},
onSelectCallback = (UnityEditorInternal.ReorderableList l) =>
{
SetAnimationByIndex(l.index);
},
onRemoveCallback = (UnityEditorInternal.ReorderableList l) =>
{
int index = l.index;
UnityEditorInternal.ReorderableList.defaultBehaviours.DoRemoveButton(l);
if (l.serializedProperty.arraySize > index)
{
reservedAnimIndex = index;
}
else if (l.serializedProperty.arraySize > 0)
{
reservedAnimIndex = l.serializedProperty.arraySize - 1;
}
}
};
animIndex = EditorPrefs.GetInt(model.GetInstanceID().ToString(), -1);
if (model.animations.Count > 0 && animIndex < 0)
{
animIndex = 0;
}
SetAnimationByIndex(animIndex);
}
protected void OnInspectorGUI_Multi()
{
EditorGUILayout.HelpBox("Displayed information is of the first selected model,\nbut any change affects all selected models.", MessageType.Info);
MeshModel[] models = new MeshModel[targets.Length];
for (int i = 0; i < models.Length; ++i)
{
models[i] = targets[i] as MeshModel;
}
MeshModel firstModel = models[0];
bool isAllSkinnedModel = true;
foreach (MeshModel model in models)
{
isAllSkinnedModel &= model.IsSkinnedModel();
}
bool isAllNotFixingToGround = true;
foreach (MeshModel model in models)
{
isAllNotFixingToGround &= (!model.isFixingToOrigin || !model.isFixingToGround);
}
PivotType pivotType = PivotType.Bottom;
bool isPivotTypeChanged = false;
bool isGroundPivot = false;
bool isGroundPivotChanged = false;
if (isAllSkinnedModel || isAllNotFixingToGround)
{
EditorGUILayout.Space();
if (isAllSkinnedModel)
{
pivotType = DrawPivotTypeField(firstModel, out isPivotTypeChanged);
}
if (isAllNotFixingToGround)
{
isGroundPivot = DrawGroundPivotField(firstModel, out isGroundPivotChanged);
}
}
bool hasAllRootBone = true;
foreach (MeshModel model in models)
{
hasAllRootBone &= (model.rootBoneObj != null);
}
bool isFixingToOrigin = false;
bool isFixingToOriginChanged = false;
bool isAllFixingToOrigin = true;
bool isAllNotGroundPivot = true;
bool isFixingToGround = false;
bool isFixingToGroundChanged = false;
if (isAllSkinnedModel && hasAllRootBone)
{
EditorGUILayout.Space();
EditorGUILayout.LabelField("Root Bone");
EditorGUI.indentLevel++;
{
isFixingToOrigin = DrawFixToOriginField(firstModel, out isFixingToOriginChanged);
foreach (MeshModel model in models)
{
isAllFixingToOrigin &= model.isFixingToOrigin;
}
foreach (MeshModel model in models)
{
isAllNotGroundPivot &= !model.isGroundPivot;
}
if (isAllFixingToOrigin && isAllNotGroundPivot)
{
EditorGUI.indentLevel++;
isFixingToGround = DrawFixToGroundField(firstModel, out isFixingToGroundChanged);
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
}
EditorGUILayout.Space();
bool isSpritePrefabChanged;
GameObject spritePrefab = DrawSpritePrefabField(firstModel, out isSpritePrefabChanged);
bool hasAllSpritePrefab = true;
foreach (MeshModel model in models)
{
hasAllSpritePrefab &= (model.spritePrefab != null);
}
PrefabBuilder prefabBuilder = null;
bool isPrefabBuilderChanged = false;
if (hasAllSpritePrefab)
{
EditorGUI.indentLevel++;
prefabBuilder = DrawPrefabBuilderField(model, out isPrefabBuilderChanged);
EditorGUI.indentLevel--;
}
EditorGUILayout.Space();
bool isNameSuffixChanged;
string nameSuffix = DrawModelNameSuffix(firstModel, out isNameSuffixChanged);
if (isNameSuffixChanged)
{
PathHelper.CorrectPathString(ref nameSuffix);
}
if (isPivotTypeChanged || isGroundPivotChanged || isFixingToOriginChanged || isFixingToGroundChanged ||
isSpritePrefabChanged || isPrefabBuilderChanged || isNameSuffixChanged)
{
foreach (MeshModel model in models)
{
Undo.RecordObject(model, "Mesh Model");
if (isAllSkinnedModel && isPivotTypeChanged)
{
model.pivotType = pivotType;
}
if (isAllNotFixingToGround && isGroundPivotChanged)
{
model.isGroundPivot = isGroundPivot;
}
if (isAllSkinnedModel && hasAllRootBone)
{
if (isFixingToOriginChanged)
{
model.isFixingToOrigin = isFixingToOrigin;
}
if (isAllFixingToOrigin && isAllNotGroundPivot && isFixingToGroundChanged)
{
model.isFixingToGround = isFixingToGround;
}
}
if (isSpritePrefabChanged)
{
model.spritePrefab = spritePrefab;
}
if (hasAllSpritePrefab && isPrefabBuilderChanged)
{
model.prefabBuilder = prefabBuilder;
}
if (isNameSuffixChanged)
{
model.nameSuffix = nameSuffix;
}
}
}
Studio studio = FindObjectOfType <Studio>();
if (studio == null)
{
return;
}
EditorGUILayout.Space();
if (DrawingHelper.DrawWideButton("Add all to the model list"))
{
foreach (MeshModel model in models)
{
AddToModelList(model);
}
}
}
private void OnInspectorGUI_Single()
{
Undo.RecordObject(model, "Mesh Model");
bool isAnyChanged = false;
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
model.mainRenderer = EditorGUILayout.ObjectField(new GUIContent("Main Renderer",
"the most important and biggest renderer in hierarchy"), model.mainRenderer, typeof(Renderer), true) as Renderer;
bool mainRendererChanged = EditorGUI.EndChangeCheck();
if (model.mainRenderer == null)
{
model.mainRenderer = MeshModel.FindBiggestRenderer(model.gameObject);
}
if (model.IsSkinnedModel())
{
EditorGUILayout.Space();
if (mainRendererChanged)
{
model.pivotType = PivotType.Bottom;
}
bool isPivotTypeChanged;
model.pivotType = DrawPivotTypeField(model, out isPivotTypeChanged);
if (isPivotTypeChanged)
{
UpdateSceneWindow();
}
}
else
{
model.pivotType = PivotType.Center;
}
if (model.isFixingToOrigin && model.isFixingToGround)
{
GUI.enabled = false;
}
{
bool isGroundPivotChanged;
model.isGroundPivot = DrawGroundPivotField(model, out isGroundPivotChanged);
if (isGroundPivotChanged)
{
UpdateSceneWindow();
}
}
if (model.isFixingToOrigin && model.isFixingToGround)
{
GUI.enabled = true;
}
if (model.IsSkinnedModel())
{
EditorGUILayout.Space();
EditorGUI.BeginChangeCheck();
model.rootBoneObj = EditorGUILayout.ObjectField(new GUIContent("Root Bone",
"root bone object to fix body"), model.rootBoneObj, typeof(Transform), true) as Transform;
if (model.rootBoneObj == null)
{
GUI.enabled = false;
}
EditorGUI.indentLevel++;
{
model.isFixingToOrigin = DrawFixToOriginField(model, out isAnyChanged);
if (model.isFixingToOrigin)
{
EditorGUI.indentLevel++;
if (model.isGroundPivot)
{
GUI.enabled = false;
}
model.isFixingToGround = DrawFixToGroundField(model, out isAnyChanged);
if (model.isGroundPivot)
{
GUI.enabled = true;
}
EditorGUI.indentLevel--;
}
}
EditorGUI.indentLevel--;
if (model.rootBoneObj == null)
{
GUI.enabled = true;
}
if (EditorGUI.EndChangeCheck())
{
model.Animate(SelectedAnimation, Frame.BEGIN);
}
}
EditorGUILayout.Space();
if (reservedAnimIndex >= 0)
{
SetAnimationByIndex(reservedAnimIndex);
reservedAnimIndex = -1;
}
Rect animBoxRect = EditorGUILayout.BeginVertical();
serializedObject.Update();
animReorderableList.DoLayoutList();
serializedObject.ApplyModifiedProperties();
EditorGUILayout.EndVertical();
switch (Event.current.type)
{
case EventType.DragUpdated:
case EventType.DragPerform:
{
if (!animBoxRect.Contains(Event.current.mousePosition))
{
break;
}
DragAndDrop.visualMode = DragAndDropVisualMode.Copy;
if (Event.current.type == EventType.DragPerform)
{
DragAndDrop.AcceptDrag();
foreach (object draggedObj in DragAndDrop.objectReferences)
{
AnimationClip clip = draggedObj as AnimationClip;
if (clip != null)
{
MeshAnimation anim = new MeshAnimation();
anim.clip = clip;
anim.selectedFrames = new List <Frame>();
model.AddAnimation(anim);
}
}
}
}
Event.current.Use();
break;
}
if (model.animations.Count > 0 && DrawingHelper.DrawMiddleButton("Clear all"))
{
model.animations.Clear();
}
EditorGUILayout.Space();
DrawReferenceControllerField();
if (model.referenceController != null)
{
EditorGUI.indentLevel++;
model.outputController = EditorGUILayout.ObjectField(new GUIContent("Output Controller",
"controller to which a baker saves animation states related to the animation list's animations"),
model.outputController, typeof(AnimatorController), false) as AnimatorController;
EditorGUI.indentLevel--;
}
EditorGUILayout.Space();
model.spritePrefab = DrawSpritePrefabField(model, out isAnyChanged);
if (model.spritePrefab != null)
{
EditorGUI.indentLevel++;
model.prefabBuilder = DrawPrefabBuilderField(model, out isAnyChanged);
EditorGUI.indentLevel--;
}
EditorGUILayout.Space();
if (SelectedAnimation != null)
{
SelectedAnimation.customizer = EditorGUILayout.ObjectField(new GUIContent("Customizer",
"component that customizes this model at every frames in the selected animation"),
SelectedAnimation.customizer, typeof(AnimationCustomizer), true) as AnimationCustomizer;
}
EditorGUILayout.Space();
bool isNameSuffixChanged;
model.nameSuffix = DrawModelNameSuffix(model, out isNameSuffixChanged);
if (isNameSuffixChanged)
{
PathHelper.CorrectPathString(ref model.nameSuffix);
}
EditorGUILayout.Space();
if (DrawingHelper.DrawWideButton("Add to the model list"))
{
AddToModelList(model);
}
}
private static void DrawBakingProgress(int editorWidth, int editorHeight, GUIStyle titleStyle, List <Model> bakingModels, Batcher batcher)
{
const float HELP_BOX_HEIGHT = 54; // help box + two spaces
const float TITLE_HEIGHT = 30; // title label + two spaces
const float BOTTOM_AREA_HEIGHT = 34; // cancel button + two spaces
float maxBodyAreaHeight = editorHeight - HELP_BOX_HEIGHT - TITLE_HEIGHT - BOTTOM_AREA_HEIGHT;
float FIELD_HEIGHT = 16;
float computedBodyHeight = 0;
for (int i = 0; i < bakingModels.Count; ++i)
{
computedBodyHeight += FIELD_HEIGHT;
Model model = bakingModels[i];
if (Model.IsMeshModel(model))
{
computedBodyHeight += Model.AsMeshModel(model).GetValidAnimations().Count *FIELD_HEIGHT;
}
}
float bodyAreaHeight = Mathf.Min(computedBodyHeight, maxBodyAreaHeight);
Rect titleRect = EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField(string.Format("Baking.. ({0}/{1})", batcher.ModelIndex, bakingModels.Count), titleStyle, GUILayout.Height(TITLE_HEIGHT + bodyAreaHeight));
EditorGUILayout.EndVertical();
float bodyY = titleRect.y + TITLE_HEIGHT;
int firstModelIndex = 0;
if (computedBodyHeight > maxBodyAreaHeight)
{
float simulatedBodyHeight = 0;
for (int i = 0; i < bakingModels.Count; ++i)
{
float totalModelHeight = FIELD_HEIGHT;
Model model = bakingModels[i];
if (Model.IsMeshModel(model))
{
totalModelHeight += Model.AsMeshModel(model).GetValidAnimations().Count *FIELD_HEIGHT;
}
float thresholdHeight = totalModelHeight + FIELD_HEIGHT * 2; // extra two for baking one & post ellipsis;
if (simulatedBodyHeight + thresholdHeight < maxBodyAreaHeight)
{
simulatedBodyHeight += totalModelHeight;
}
else
{
if (i > batcher.ModelIndex)
{
break;
}
firstModelIndex++;
if (firstModelIndex == 1)
{
simulatedBodyHeight += FIELD_HEIGHT; // for pre ellipsis
}
}
}
}
Debug.Assert(firstModelIndex < bakingModels.Count);
GUIStyle labelStyle = new GUIStyle();
labelStyle.normal.textColor = EditorGUIUtility.isProSkin ? Color.white : Color.black;
{ // progress bar
int totalTargetCount = 0;
int ongoingTargetCount = 0;
for (int i = 0; i < bakingModels.Count; ++i)
{
Model model = bakingModels[i];
if (Model.IsMeshModel(model))
{
int validAnimationCount = Model.AsMeshModel(model).GetValidAnimations().Count;
if (validAnimationCount > 0)
{
totalTargetCount += validAnimationCount;
if (i < batcher.ModelIndex)
{
ongoingTargetCount += validAnimationCount;
}
else if (i == batcher.ModelIndex)
{
MeshBaker animationBaker = batcher.CurrentBaker as MeshBaker;
if (animationBaker != null)
{
ongoingTargetCount += animationBaker.AnimationIndex;
}
}
}
else
{
totalTargetCount++;
if (i <= batcher.ModelIndex)
{
ongoingTargetCount++;
}
}
}
else
{
totalTargetCount++;
if (i <= batcher.ModelIndex)
{
ongoingTargetCount++;
}
}
}
float progress = (float)ongoingTargetCount / (float)totalTargetCount;
const float PROGRESS_BAR_WIDTH = 10;
Rect progressBarBgRect = new Rect(editorWidth, bodyY, PROGRESS_BAR_WIDTH, bodyAreaHeight);
DrawingHelper.FillRect(progressBarBgRect, EditorGUIUtility.isProSkin ? lightGrayColor : darkGrayColor);
Rect progressBarFgRect = new Rect(editorWidth, bodyY, PROGRESS_BAR_WIDTH, bodyAreaHeight * progress);
DrawingHelper.FillRect(progressBarFgRect, EditorGUIUtility.isProSkin ? Color.white : Color.black);
labelStyle.alignment = TextAnchor.MiddleRight;
float progressLabelY = bodyY + bodyAreaHeight * progress - (FIELD_HEIGHT / 2);
Rect progressLabelRect = new Rect(14, progressLabelY, editorWidth - 17, FIELD_HEIGHT);
EditorGUI.LabelField(progressLabelRect, string.Format("{0:0}%", progress * 100), labelStyle);
}
labelStyle.alignment = TextAnchor.MiddleLeft;
float FIELD_X = 14;
float bodyHeight = 0;
if (firstModelIndex > 0)
{
Rect ellipsisRect = new Rect(FIELD_X, bodyY + bodyHeight, editorWidth, FIELD_HEIGHT);
EditorGUI.indentLevel++; EditorGUI.indentLevel++;
EditorGUI.LabelField(ellipsisRect, "...", labelStyle);
EditorGUI.indentLevel--; EditorGUI.indentLevel--;
bodyHeight += FIELD_HEIGHT;
}
for (int mi = firstModelIndex; mi < bakingModels.Count; ++mi)
{
if (bodyHeight + FIELD_HEIGHT > maxBodyAreaHeight)
{
return;
}
Model model = bakingModels[mi];
Rect modelRect = new Rect(FIELD_X, bodyY + bodyHeight, editorWidth, FIELD_HEIGHT);
bodyHeight += FIELD_HEIGHT;
FieldState state = FieldState.None;
if (mi < batcher.ModelIndex)
{
state = FieldState.Completed;
}
else if (mi == batcher.ModelIndex)
{
state = FieldState.Baking;
}
bool elliptical = false;
if (bodyHeight + FIELD_HEIGHT > maxBodyAreaHeight)
{
if (mi < bakingModels.Count - 1)
{
elliptical = true;
}
}
string labelText;
if (elliptical)
{
labelText = "...";
}
else
{
labelText = mi.ToString() + ". " + model.name;
if (model.nameSuffix.Length > 0)
{
labelText += model.nameSuffix;
}
}
labelStyle.fontStyle = GetLabelFontStyle(state);
EditorGUI.indentLevel++;
EditorGUI.LabelField(modelRect, labelText, labelStyle);
EditorGUI.indentLevel--;
if (state == FieldState.Completed && !elliptical)
{
DrawCheckMark(modelRect);
}
if (Model.IsMeshModel(model))
{
MeshModel meshModel = Model.AsMeshModel(model);
List <MeshAnimation> validAnimations = meshModel.GetValidAnimations();
for (int ai = 0; ai < validAnimations.Count; ++ai)
{
if (bodyHeight + FIELD_HEIGHT > maxBodyAreaHeight)
{
return;
}
MeshAnimation anim = validAnimations[ai];
MeshBaker animationBaker = batcher.CurrentBaker as MeshBaker;
Rect animationRect = new Rect(FIELD_X, bodyY + bodyHeight, editorWidth, FIELD_HEIGHT);
bodyHeight += FIELD_HEIGHT;
state = FieldState.None;
if (mi < batcher.ModelIndex || (mi == batcher.ModelIndex && (animationBaker != null && ai < animationBaker.AnimationIndex)))
{
state = FieldState.Completed;
}
else if (mi == batcher.ModelIndex && (animationBaker != null && ai == animationBaker.AnimationIndex))
{
state = FieldState.Baking;
}
elliptical = false;
if (bodyHeight + FIELD_HEIGHT > maxBodyAreaHeight)
{
if (mi < bakingModels.Count - 1 || ai < validAnimations.Count - 1)
{
elliptical = true;
}
}
if (elliptical)
{
labelText = "...";
}
else
{
labelText = (meshModel.referenceController != null) ? anim.stateName : anim.clip.name;
}
labelStyle.fontStyle = GetLabelFontStyle(state);
EditorGUI.indentLevel++; EditorGUI.indentLevel++;
EditorGUI.LabelField(animationRect, labelText, labelStyle);
EditorGUI.indentLevel--; EditorGUI.indentLevel--;
if (state == FieldState.Completed && !elliptical)
{
DrawCheckMark(animationRect, 10);
}
}
}
}
}
private static void MakeRendererModels()
{
GameObject groupObject = null;
List <MeshModel> models = null;
string[] selectedPathes = GetSelectedPathes();
string[] allAssetPaths = AssetDatabase.GetAllAssetPaths();
foreach (string assetPath in allAssetPaths)
{
if (!IsInAnyPathes(assetPath, selectedPathes))
{
continue;
}
GameObject prefab = AssetDatabase.LoadAssetAtPath(assetPath, typeof(GameObject)) as GameObject;
if (prefab == null)
{
continue;
}
Renderer renderer = prefab.GetComponentInChildren <Renderer>();
if (renderer == null)
{
continue;
}
if (groupObject == null)
{
groupObject = new GameObject("Mesh Model Group");
models = new List <MeshModel>();
}
GameObject obj = GameObject.Instantiate(prefab, Vector3.zero, Quaternion.identity, groupObject.transform);
obj.name = prefab.name;
MeshModel model = obj.GetComponent <MeshModel>();
if (model == null)
{
model = obj.AddComponent <MeshModel>();
if (model.mainRenderer is SkinnedMeshRenderer)
{
model.pivotType = PivotType.Bottom;
}
else
{
model.pivotType = PivotType.Center;
}
}
if (model.mainRenderer == null)
{
model.mainRenderer = MeshModel.FindBiggestRenderer(obj);
}
models.Add(model);
}
if (models != null)
{
foreach (MeshModel model in models)
{
float rangeX = model.mainRenderer.bounds.size.x * models.Count;
float rangeZ = model.mainRenderer.bounds.size.z * models.Count;
model.transform.position = new Vector3(Random.Range(-rangeX, rangeX), 0, Random.Range(-rangeZ, rangeZ));
}
}
}
public void UpdateState()
{
try
{
if (CurrentBaker != null)
{
if (CurrentBaker.IsInProgress())
{
CurrentBaker.UpdateState();
if (CurrentBaker.IsCancelled)
{
throw new Exception("Cancelled");
}
return;
}
else
{
EditorUtility.ClearProgressBar();
ModelIndex++;
}
}
Model model = NextModel();
if (model != null)
{
string sIndex = "";
if (modelList.Count > 1)
{
sIndex = ModelIndex.ToString().PadLeft((modelList.Count + 1).ToString().Length, '0');
}
for (int i = 0; i < modelList.Count; ++i)
{
modelList[i].gameObject.SetActive(false);
}
model.gameObject.SetActive(true);
if (Model.IsMeshModel(model))
{
MeshModel meshModel = Model.AsMeshModel(model);
List <MeshAnimation> validAnimations = meshModel.GetValidAnimations();
if (validAnimations.Count > 0)
{
CurrentBaker = new MeshBaker(model, validAnimations, studio, sIndex, batchingFolderPath);
}
else
{
CurrentBaker = new StaticBaker(model, studio, sIndex, batchingFolderPath);
}
}
else if (Model.IsParticleModel(model))
{
CurrentBaker = new ParticleBaker(model, studio, sIndex, batchingFolderPath);
}
}
else
{
EditorUtility.FocusProjectWindow();
if (needPassingFinalUpdate)
{
needPassingFinalUpdate = false;
return;
}
Finish();
}
}
catch (Exception e)
{
Debug.LogException(e);
Finish();
}
}
