public MaterialInfo(Material mat, int slotIndex)
{
MaterialSlotIndices = new List <int>();
AddSlotIndex(slotIndex);
Name = mat.name;
Texture = RendererUtility.GetMainTexture(mat);
}
/// <summary>
/// メッシュを削除する
/// </summary>
/// <param name="renderer"></param>
/// <param name="deleteTexPos"></param>
/// <param name="texture"></param>
/// <param name="subMeshIndexInDeletedVertex"></param>
private bool DeleteMesh(Renderer renderer, bool[] deletePos, MaterialInfo matInfo)
{
var texture = matInfo.Texture;
var materialIndexList = matInfo.MaterialSlotIndices;
var mesh = RendererUtility.GetMesh(renderer);
var materials = renderer.sharedMaterials.ToArray();
var textureSize = new Vector2Int(texture.width, texture.height);
var(deletedMesh, hadDeletedSubMeshes) = MeshDeleter.RemoveTriangles(mesh, deletePos, textureSize, materialIndexList);
if (meshName == "")
{
meshName = mesh.name + MESH_SUFFIX;
}
AssetDatabase.CreateAsset(deletedMesh, AssetDatabase.GenerateUniqueAssetPath(Path.Combine(saveFolder, $"{meshName}.asset")));
AssetDatabase.SaveAssets();
Undo.RecordObject(renderer, "Change mesh " + deletedMesh.name);
previousMesh = mesh;
previousMaterials = renderer.sharedMaterials;
RendererUtility.SetMesh(renderer, deletedMesh);
if (hadDeletedSubMeshes.Any(deletedSubMesh => deletedSubMesh == true))
{
// サブメッシュ削除によってマテリアルの対応を変更する必要がある
renderer.sharedMaterials = materials.Where((material, index) => !hadDeletedSubMeshes[index]).ToArray();
return(true);
}
return(false);
}
public void GetMeshIsNotNull()
{
Setup();
foreach (var model in models)
{
var mesh = RendererUtility.GetMesh(model.renderer);
Assert.IsNotNull(mesh);
}
}
public void GetMeshPathIsCorrect()
{
Setup();
foreach (var model in models)
{
var mesh = RendererUtility.GetMesh(model.renderer);
var path = RendererUtility.GetMeshPath(mesh);
Assert.AreEqual(path, model.modelDataPath);
}
}
/// <summary>
/// Remove vertex color from the target.
/// </summary>
internal void RemoveVertexColor()
{
Renderer[] skinnedMeshRenderers = target.GetComponentsInChildren <SkinnedMeshRenderer>(true);
Renderer[] meshRenderers = target.GetComponentsInChildren <MeshRenderer>(true);
foreach (var renderer in skinnedMeshRenderers.Concat(meshRenderers))
{
RendererUtility.RemoveVertexColor(renderer);
}
}
public void GetMeshTriangleCountIsCorrect()
{
Setup();
foreach (var model in models)
{
var mesh = RendererUtility.GetMesh(model.renderer);
var triangleCount = RendererUtility.GetMeshTriangleCount(mesh);
Assert.AreEqual(triangleCount, model.rendererMeshTriangleCount);
}
}
public void RevertMeshToPreviously(CanvasView canvasView)
{
ResetMaterialsToDefault(renderer);
RendererUtility.SetMesh(renderer, previousMesh);
previousMesh = null;
renderer.sharedMaterials = previousMaterials;
previousMaterials = null;
Initialize(canvasView, false);
}
public void RevertMeshToPrefab(CanvasView canvasView)
{
ResetMaterialsToDefault(renderer);
RendererUtility.RevertMeshToPrefab(renderer);
canvasView.uvMap.SetUVMapTexture(renderer, matInfos[materialInfoIndex]);
Initialize(canvasView, false);
previousMesh = null;
previousMaterials = null;
}
/// <summary>
/// Sets the visibility.
/// </summary>
/// <param name="aIsVisible_boolean">If set to <c>true</c> a is visible_boolean.</param>
public void setVisibility(bool aIsVisible_boolean)
{
RendererUtility.SetMaterialVisibility(_scoreGUIText.guiText.material, aIsVisible_boolean);
RendererUtility.SetMaterialVisibility(_scoreGUIText2.guiText.material, aIsVisible_boolean);
RendererUtility.SetMaterialVisibility(_healthGUIText.guiText.material, aIsVisible_boolean);
RendererUtility.SetMaterialVisibility(_healthGUIText2.guiText.material, aIsVisible_boolean);
RendererUtility.SetMaterialVisibility(_fpsGUIText.guiText.material, aIsVisible_boolean);
//KEEP HERE AS REMINDER
//SINCE WE FADE THIS TEXT MANUALLY, DON'T SET VISIBILITY HERE
//RendererUtility.SetMaterialVisibility (_promptGUIText.guiText.material, aIsVisible_boolean);
//RendererUtility.SetMaterialVisibility (_promptGUIText2.guiText.material, aIsVisible_boolean);
}
public void GetMainTexturesNameIsCorrect()
{
Setup();
foreach (var model in models)
{
var textures = RendererUtility.GetMainTextures(model.renderer);
Assert.AreEqual(textures.Length, model.textureNames.Length);
for (int i = 0; i < textures.Length; i++)
{
Assert.AreEqual(textures[i].name, model.textureNames[i]);
}
}
}
/// <summary>
/// Dos the prompt start.
/// </summary>
/// <param name="aMessage_string">A message_string.</param>
public void doPromptStart(string aMessage_string, bool aIsToFadeOutToo_boolean)
{
//DON'T SET IMMEDIATLY. SEE 'Update()' above
_lastPromptMessage_string = aMessage_string;
//SETUP: IMMEDIATLY SET ALPHA TO 0
RendererUtility.SetMaterialAlpha(_promptGUIText.guiText.material, 0);
RendererUtility.SetMaterialAlpha(_promptGUIText2.guiText.material, 0);
/*********
*
* SETUP: FADE FROM 0 TO 100
*
********/
Hashtable fadeTo2_hashtable = new Hashtable();
fadeTo2_hashtable.Add(iT.FadeTo.delay, .1f);
fadeTo2_hashtable.Add(iT.FadeTo.amount, 1);
fadeTo2_hashtable.Add(iT.FadeTo.time, .5);
fadeTo2_hashtable.Add(iT.FadeTo.easetype, iTween.EaseType.linear);
//
iTween.FadeTo(promptGUIText_gameObject, fadeTo2_hashtable);
iTween.FadeTo(promptGUIText2_gameObject, fadeTo2_hashtable);
/*********
*
* SETUP: FADE FROM 100 TO 0
*
********/
//_promptGUIText.font.material.color.a = 0.5f;
if (aIsToFadeOutToo_boolean)
{
Hashtable fadeTo3_hashtable = new Hashtable();
fadeTo3_hashtable.Add("name", "fadeTo2");
fadeTo3_hashtable.Add(iT.FadeTo.delay, 2);
fadeTo3_hashtable.Add(iT.FadeTo.alpha, 0);
fadeTo3_hashtable.Add(iT.FadeTo.time, .5);
fadeTo3_hashtable.Add(iT.FadeTo.easetype, iTween.EaseType.linear);
fadeTo3_hashtable.Add(iT.FadeTo.oncompletetarget, gameObject);
//
iTween.FadeTo(promptGUIText_gameObject, fadeTo3_hashtable);
//CALL COMPLETE JUST ONCE
fadeTo3_hashtable.Add(iT.FadeTo.oncomplete, "_onPromptFadeOutComplete");
iTween.FadeTo(promptGUIText2_gameObject, fadeTo3_hashtable);
}
}
/// <summary>
/// Rendererから必要な情報を取得
/// </summary>
/// <param name="renderer"></param>
/// <param name="mesh"></param>
private void LoadRendererData(Renderer renderer)
{
var mesh = RendererUtility.GetMesh(renderer);
if (mesh == null)
{
return;
}
triangleCount = RendererUtility.GetMeshTriangleCount(mesh);
saveFolder = RendererUtility.GetMeshPath(mesh);
defaultMaterials = RendererUtility.GetMaterials(renderer);
matInfos = RendererUtility.GetMaterialInfos(renderer);
textureNames = matInfos.Select(x => x.Name).ToArray();
meshName = StringUtility.AddKeywordToEnd(mesh.name, MESH_SUFFIX);
}
public bool SetUVMapTexture(Renderer renderer, MaterialInfo materialInfo)
{
if (renderer == null || materialInfo == null)
{
editMat.SetTexture("_UVMap", null);
return(true);
}
var mesh = RendererUtility.GetMesh(renderer);
if (mesh == null)
{
return(false);
}
uvMapTexture = GenerateUVMap(mesh, materialInfo);
editMat.SetTexture("_UVMap", uvMapTexture);
return(true);
}
public void SetMeshIsCorrect()
{
var mesh = new Mesh
{
name = "mesh2",
vertices = new Vector3[]
{
new Vector3(0, 0, 0),
new Vector3(0, 1, 0),
new Vector3(1, 0, 0)
},
triangles = new int[] { 0, 1, 2 }
};
Setup();
foreach (var model in models)
{
RendererUtility.SetMesh(model.renderer, mesh);
Assert.AreEqual(model.renderer.sharedMesh, mesh);
}
}
/// <summary>
/// Executes copy blendshape weights.
/// </summary>
internal void CopyBlendShapesCopy()
{
Undo.RecordObject(targetMesh, "Copy BlendShape Weights");
RendererUtility.CopyBlendShapesWeights(sourceMesh, targetMesh);
}
/// <summary>
/// Dos the prompt start.
/// </summary>
/// <param name="aMessage_string">A message_string.</param>
public void doPromptStart(string aMessage_string, bool aIsToFadeOutToo_boolean)
{
//DON'T SET IMMEDIATLY. SEE 'Update()' above
_lastPromptMessage_string = aMessage_string;
//FOR DEVELOPMENT: ALLOW TO SKIP VIA INSPECTOR WINDOW DROPDOWN
float fadeInDuration_float;
float fadeOutDuration_float;
float fadeOutDelayDuration_float;
if (hudMode == HUDMode.Show)
{
fadeInDuration_float = 0.5f;
fadeOutDuration_float = 0.5f;
fadeOutDelayDuration_float = 2f;
}
else
{
fadeInDuration_float = 0.1f;
fadeOutDuration_float = 0.1f;
fadeOutDelayDuration_float = .1f;
}
//SETUP: IMMEDIATLY SET ALPHA TO 0
RendererUtility.SetMaterialAlpha(_promptGUIText.guiText.material, 0);
RendererUtility.SetMaterialAlpha(_promptGUIText2.guiText.material, 0);
/*********
*
* SETUP: FADE FROM 0 TO 100
*
********/
Hashtable fadeTo2_hashtable = new Hashtable();
fadeTo2_hashtable.Add(iT.FadeTo.delay, .1f);
fadeTo2_hashtable.Add(iT.FadeTo.amount, 1);
fadeTo2_hashtable.Add(iT.FadeTo.time, fadeInDuration_float);
fadeTo2_hashtable.Add(iT.FadeTo.easetype, iTween.EaseType.linear);
//
iTween.FadeTo(promptGUIText_gameObject, fadeTo2_hashtable);
iTween.FadeTo(promptGUIText2_gameObject, fadeTo2_hashtable);
/*********
*
* SETUP: FADE FROM 100 TO 0
*
********/
//_promptGUIText.font.material.color.a = 0.5f;
if (aIsToFadeOutToo_boolean)
{
Hashtable fadeTo3_hashtable = new Hashtable();
fadeTo3_hashtable.Add("name", "fadeTo2");
fadeTo3_hashtable.Add(iT.FadeTo.delay, fadeOutDelayDuration_float);
fadeTo3_hashtable.Add(iT.FadeTo.alpha, 0);
fadeTo3_hashtable.Add(iT.FadeTo.time, fadeOutDuration_float);
fadeTo3_hashtable.Add(iT.FadeTo.easetype, iTween.EaseType.linear);
fadeTo3_hashtable.Add(iT.FadeTo.oncompletetarget, gameObject);
//
iTween.FadeTo(promptGUIText_gameObject, fadeTo3_hashtable);
//CALL COMPLETE JUST ONCE
fadeTo3_hashtable.Add(iT.FadeTo.oncomplete, "_onPromptFadeOutComplete");
iTween.FadeTo(promptGUIText2_gameObject, fadeTo3_hashtable);
}
}
private void ResetMaterialsToDefault(Renderer renderer) => RendererUtility.SetMaterials(renderer, defaultMaterials);
/// <summary>
/// Sets the click text is visible.
/// </summary>
/// <param name="isVisible_boolean">Is visible_boolean.</param>
public void setClickTextIsVisible(bool isVisible_boolean)
{
RendererUtility.SetMaterialVisibility(_clickGUIText.material, isVisible_boolean);
}
private void CalcuateLayer(Map map, Area exportArea, float areaDiameter)
{
Dictionary <int, UnitInfo> unitInfos = new Dictionary <int, UnitInfo>();
CalcuateAllPrefab(exportArea.gameObject, unitInfos);
List <GameObject> unitObjs = new List <GameObject>();
foreach (var unitInfo in unitInfos)
{
unitObjs.Add(unitInfo.Value.Unit);
}
if (unitObjs != null && unitObjs.Count > 0)
{
float totalDiameter = 0f;
unitObjs.Sort((unit1, unit2) =>
{
UnitInfo info1 = unitInfos[unit1.GetInstanceID()];
UnitInfo info2 = unitInfos[unit2.GetInstanceID()];
Bounds unit1AABB = info1.AABB;
float unit1Diameter = Mathf.Max(unit1AABB.size.x, unit1AABB.size.y, unit1AABB.size.z);
Bounds unit2AABB = info2.AABB;
float unit2Diameter = Mathf.Max(unit2AABB.size.x, unit2AABB.size.y, unit2AABB.size.z);
return(unit1Diameter.CompareTo(unit2Diameter));
});
for (int iUnit = 0; iUnit < unitObjs.Count; iUnit++)
{
GameObject unit = unitObjs[iUnit];
UnitInfo unitInfo = unitInfos[unit.GetInstanceID()];
Bounds unitAABB = unitInfo.AABB;
EditorUtility.DisplayProgressBar("analyze", unit.name, iUnit / unitObjs.Count);
float unitDiameter = Mathf.Max(unitAABB.size.x, unitAABB.size.y, unitAABB.size.z);
totalDiameter += unitDiameter;
}
m_EditorSplitAreaLayerSettings.Clear();
float avergeDiameter = totalDiameter / unitObjs.Count;
EditorSplitAreaLayerSetting layerInfo = new EditorSplitAreaLayerSetting();
layerInfo.m_MaxAABBSize = areaDiameter;
layerInfo.m_MinAABBSize = avergeDiameter;
layerInfo.m_LayerName = AreaLayer.BigLayer.ToString();
layerInfo.m_Priority = (int)AreaLayer.BigLayer;
layerInfo.m_GridSize = Mathf.Max(Mathf.CeilToInt(areaDiameter), 1);
float avergeHalfDiameter = avergeDiameter / 3;
float halfDiameter = avergeDiameter - 2 * avergeHalfDiameter;
EditorSplitAreaLayerSetting layerInfoMedium = new EditorSplitAreaLayerSetting();
layerInfoMedium.m_MaxAABBSize = avergeDiameter;
layerInfoMedium.m_MinAABBSize = halfDiameter;
layerInfoMedium.m_LayerName = AreaLayer.MediumLayer.ToString();
layerInfoMedium.m_Priority = (int)AreaLayer.MediumLayer;
layerInfoMedium.m_GridSize = Mathf.Max(Mathf.CeilToInt(avergeDiameter), 1);
EditorSplitAreaLayerSetting layerInfoSmall = new EditorSplitAreaLayerSetting();
layerInfoSmall.m_MaxAABBSize = halfDiameter;
layerInfoSmall.m_MinAABBSize = 0;
layerInfoSmall.m_LayerName = AreaLayer.SmallLayer.ToString();
layerInfoSmall.m_Priority = (int)AreaLayer.SmallLayer;
layerInfoSmall.m_GridSize = Mathf.Max(Mathf.CeilToInt(halfDiameter), 1);
float layer1MaxDiameter = -1f; //层1中的unit最大直径
float layer2MaxDiameter = -1f; //层2中的unit最大直径
float layer3MaxDiameter = -1f; //层3中的unit最大直径
//TODO:计算27宫格偏移
for (int iUnit = 0; iUnit < unitObjs.Count; iUnit++)
{
GameObject unit = unitObjs[iUnit];
Bounds unitAABB = unitInfos[unit.GetInstanceID()].AABB;
EditorUtility.DisplayProgressBar("analyze", unit.name, iUnit / unitObjs.Count);
float unitDiameter = Mathf.Max(unitAABB.size.x, unitAABB.size.y, unitAABB.size.z);
if (unitDiameter > avergeDiameter && unitDiameter <= areaDiameter)//big layer
{
if (layer1MaxDiameter < unitDiameter)
{
layer1MaxDiameter = unitDiameter;
}
}
else if (unitDiameter > halfDiameter && unitDiameter <= avergeDiameter)//medium layer
{
if (layer2MaxDiameter < unitDiameter)
{
layer2MaxDiameter = unitDiameter;
}
}
else if (unitDiameter > 0 && unitDiameter <= halfDiameter)//small layer
{
if (layer3MaxDiameter < unitDiameter)
{
layer3MaxDiameter = unitDiameter;
}
}
}
float halfTanCameraFov = RendererUtility.CaculateHalfTanCameraFov(map.ExpectedFov);
float toCameraDistance = RendererUtility.CacluateToCameraDistance(layer1MaxDiameter, m_EditorSplitAreaSetting.m_Rate, halfTanCameraFov);
toCameraDistance = Mathf.Min(toCameraDistance, exportArea.GetDiameter());
layerInfo.m_Offest = Mathf.Clamp(Mathf.CeilToInt(toCameraDistance / layerInfo.m_GridSize), (int)GridOffest.Min, (int)GridOffest.Max);
toCameraDistance = RendererUtility.CacluateToCameraDistance(layer2MaxDiameter, m_EditorSplitAreaSetting.m_Rate, halfTanCameraFov);
layerInfoMedium.m_Offest = Mathf.Clamp(Mathf.CeilToInt(toCameraDistance / layerInfoMedium.m_GridSize), (int)GridOffest.Min, (int)GridOffest.Max);
toCameraDistance = RendererUtility.CacluateToCameraDistance(layer3MaxDiameter, m_EditorSplitAreaSetting.m_Rate, halfTanCameraFov);
layerInfoSmall.m_Offest = Mathf.Clamp(Mathf.CeilToInt(toCameraDistance / layerInfoSmall.m_GridSize), (int)GridOffest.Min, (int)GridOffest.Max);
m_EditorSplitAreaLayerSettings.Add(layerInfo);
m_EditorSplitAreaLayerSettings.Add(layerInfoMedium);
m_EditorSplitAreaLayerSettings.Add(layerInfoSmall);
}
}
/// <summary>
/// Sets the logo texture is visible.
/// </summary>
/// <param name="isVisible_boolean">If set to <c>true</c> is visible_boolean.</param>
public void setLogoTextureIsVisible(bool isVisible_boolean)
{
RendererUtility.SetGUITextureVisibility(_logo_guitexture, isVisible_boolean);
}
/// <summary>
/// Sets the visibility for restart GU.
/// </summary>
/// <param name="aIsVisible_boolean">If set to <c>true</c> a is visible_boolean.</param>
public void setVisibilityForRestartGUI(bool aIsVisible_boolean)
{
RendererUtility.SetMaterialVisibility(_restartGUIText.guiText.material, aIsVisible_boolean);
RendererUtility.SetMaterialVisibility(_restartGUIText2.guiText.material, aIsVisible_boolean);
}
