internal Matrix4x4[] GetBindposes(Renderer r)
{
MeshChannels mc;
Mesh m = MB_Utility.GetMesh(r.gameObject);
if (!meshID2MeshChannels.TryGetValue(m.GetInstanceID(), out mc))
{
mc = new MeshChannels();
meshID2MeshChannels.Add(m.GetInstanceID(), mc);
}
if (mc.bindPoses == null)
{
mc.bindPoses = _getBindPoses(r);
}
return(mc.bindPoses);
}
internal BoneWeight[] GetBoneWeights(Renderer r, int numVertsInMeshBeingAdded)
{
MeshChannels mc;
Mesh m = MB_Utility.GetMesh(r.gameObject);
if (!meshID2MeshChannels.TryGetValue(m.GetInstanceID(), out mc))
{
mc = new MeshChannels();
meshID2MeshChannels.Add(m.GetInstanceID(), mc);
}
if (mc.boneWeights == null)
{
mc.boneWeights = _getBoneWeights(r, numVertsInMeshBeingAdded);
}
return(mc.boneWeights);
}
static public Mesh BakeOneMesh(MB3_MeshCombinerSingle mom, string newMeshFilePath, GameObject objToBake)
{
Mesh outMesh = null;
if (objToBake == null)
{
Debug.LogError("An object on the list of objects to combine is 'None'. Use Command-Delete on Mac OS X; Delete or Shift-Delete on Windows to remove this one element.");
return(null);
}
MB3_EditorMethods editorMethods = new MB3_EditorMethods();
GameObject[] objs = new GameObject[] { objToBake };
Renderer r = MB_Utility.GetRenderer(objToBake);
if (r is SkinnedMeshRenderer)
{
mom.renderType = MB_RenderType.skinnedMeshRenderer;
}
else if (r is MeshRenderer)
{
mom.renderType = MB_RenderType.meshRenderer;
}
else
{
Debug.LogError("Unsupported Renderer type on object. Must be SkinnedMesh or MeshFilter.");
return(null);
}
if (newMeshFilePath == null && newMeshFilePath.Length != 0) //todo check directory exists
{
Debug.LogError("File path was not in assets folder.");
return(null);
}
if (mom.AddDeleteGameObjects(objs, null, false))
{
mom.Apply(MB3_MeshBakerEditorFunctions.UnwrapUV2);
Mesh mf = MB_Utility.GetMesh(objToBake);
if (mf != null)
{
Debug.Log("Creating mesh for " + objToBake.name + " with adjusted UVs at: " + newMeshFilePath);
AssetDatabase.CreateAsset(mom.GetMesh(), newMeshFilePath);
outMesh = (Mesh)AssetDatabase.LoadAssetAtPath(newMeshFilePath, typeof(Mesh));
}
}
mom.DestroyMeshEditor(editorMethods);
return(outMesh);
}
static public bool BakeOneMesh(MB3_MeshCombinerSingle mom, Mesh targMesh, GameObject objToBake)
{
if (objToBake == null)
{
Debug.LogError("An object on the list of objects to combine is 'None'. Use Command-Delete on Mac OS X; Delete or Shift-Delete on Windows to remove this one element.");
return(false);
}
if (targMesh == null)
{
Debug.LogError("No mesh was provided.");
return(false);
}
mom.SetMesh(targMesh);
mom.ClearMesh();
GameObject[] objs = new GameObject[] { objToBake };
Renderer r = MB_Utility.GetRenderer(objToBake);
if (r is SkinnedMeshRenderer)
{
mom.renderType = MB_RenderType.skinnedMeshRenderer;
}
else if (r is MeshRenderer)
{
mom.renderType = MB_RenderType.meshRenderer;
}
else
{
Debug.LogError("Unsupported Renderer type on object. Must be SkinnedMesh or MeshFilter.");
return(false);
}
if (mom.AddDeleteGameObjects(objs, null, false))
{
mom.Apply(MB3_MeshBakerEditorFunctions.UnwrapUV2);
Mesh mf = MB_Utility.GetMesh(objToBake);
if (mf == null)
{
Debug.LogError("Failed to create mesh for " + objToBake.name);
return(false);
}
}
return(true);
}
MB3_MeshBakerCommon AddMeshBaker(MB3_MeshBakerGrouper grouper, MB3_TextureBaker tb, string key, List <Renderer> gaws)
{
int numVerts = 0;
for (int i = 0; i < gaws.Count; i++)
{
Mesh m = MB_Utility.GetMesh(gaws[i].gameObject);
if (m != null)
{
numVerts += m.vertexCount;
}
}
GameObject nmb = new GameObject("MeshBaker-" + key);
nmb.transform.position = Vector3.zero;
MB3_MeshBakerCommon newMeshBaker;
if (numVerts >= 65535)
{
newMeshBaker = nmb.AddComponent <MB3_MultiMeshBaker>();
newMeshBaker.useObjsToMeshFromTexBaker = false;
}
else
{
newMeshBaker = nmb.AddComponent <MB3_MeshBaker>();
newMeshBaker.useObjsToMeshFromTexBaker = false;
}
newMeshBaker.textureBakeResults = tb.textureBakeResults;
newMeshBaker.transform.parent = tb.transform;
newMeshBaker.meshCombiner.settingsHolder = grouper;
for (int i = 0; i < gaws.Count; i++)
{
newMeshBaker.GetObjectsToCombine().Add(gaws[i].gameObject);
}
return(newMeshBaker);
}
public static Matrix4x4[] _getBindPoses(Renderer r, out bool isSkinnedMeshWithBones)
{
Matrix4x4[] poses = null;
isSkinnedMeshWithBones = r is SkinnedMeshRenderer;
if (r is SkinnedMeshRenderer)
{
poses = ((SkinnedMeshRenderer)r).sharedMesh.bindposes;
if (poses.Length == 0)
{
Mesh m = MB_Utility.GetMesh(r.gameObject);
if (m.blendShapeCount > 0)
{
isSkinnedMeshWithBones = false;
}
else
{
Debug.LogError("Skinned mesh " + r + " had no bindposes AND no blend shapes");
}
}
}
if (r is MeshRenderer ||
(r is SkinnedMeshRenderer && !isSkinnedMeshWithBones)) // It is possible for a skinned mesh to have blend shapes but no bones. These need to be treated like MeshRenderer meshes.
{
Matrix4x4 bindPose = Matrix4x4.identity;
poses = new Matrix4x4[1];
poses[0] = bindPose;
}
if (poses == null)
{
Debug.LogError("Could not _getBindPoses. Object does not have a renderer");
return(null);
}
return(poses);
}
public void SuggestTreatment(List <GameObject> objsToMesh, Material[] resultMaterials, List <ShaderTextureProperty> _customShaderPropNames)
{
this._customShaderPropNames = _customShaderPropNames;
StringBuilder sb = new StringBuilder();
Dictionary <int, MB_Utility.MeshAnalysisResult[]> meshAnalysisResultsCache = new Dictionary <int, MB_Utility.MeshAnalysisResult[]>(); //cache results
for (int i = 0; i < objsToMesh.Count; i++)
{
GameObject obj = objsToMesh[i];
if (obj == null)
{
continue;
}
Material[] ms = MB_Utility.GetGOMaterials(objsToMesh[i]);
if (ms.Length > 1)
{ // and each material is not mapped to its own layer
sb.AppendFormat("\nObject {0} uses {1} materials. Possible treatments:\n", objsToMesh[i].name, ms.Length);
sb.AppendFormat(" 1) Collapse the submeshes together into one submesh in the combined mesh. Each of the original submesh materials will map to a different UV rectangle in the atlas(es) used by the combined material.\n");
sb.AppendFormat(" 2) Use the multiple materials feature to map submeshes in the source mesh to submeshes in the combined mesh.\n");
}
Mesh m = MB_Utility.GetMesh(obj);
MB_Utility.MeshAnalysisResult[] mar;
if (!meshAnalysisResultsCache.TryGetValue(m.GetInstanceID(), out mar))
{
mar = new MB_Utility.MeshAnalysisResult[m.subMeshCount];
MB_Utility.doSubmeshesShareVertsOrTris(m, ref mar[0]);
for (int j = 0; j < m.subMeshCount; j++)
{
MB_Utility.hasOutOfBoundsUVs(m, ref mar[j], j);
//DRect outOfBoundsUVRect = new DRect(mar[j].uvRect);
mar[j].hasOverlappingSubmeshTris = mar[0].hasOverlappingSubmeshTris;
mar[j].hasOverlappingSubmeshVerts = mar[0].hasOverlappingSubmeshVerts;
}
meshAnalysisResultsCache.Add(m.GetInstanceID(), mar);
}
for (int j = 0; j < ms.Length; j++)
{
if (mar[j].hasOutOfBoundsUVs)
{
DRect r = new DRect(mar[j].uvRect);
sb.AppendFormat("\nObject {0} submesh={1} material={2} uses UVs outside the range 0,0 .. 1,1 to create tiling that tiles the box {3},{4} .. {5},{6}. This is a problem because the UVs outside the 0,0 .. 1,1 " +
"rectangle will pick up neighboring textures in the atlas. Possible Treatments:\n", obj, j, ms[j], r.x.ToString("G4"), r.y.ToString("G4"), (r.x + r.width).ToString("G4"), (r.y + r.height).ToString("G4"));
sb.AppendFormat(" 1) Ignore the problem. The tiling may not affect result significantly.\n");
sb.AppendFormat(" 2) Use the 'fix out of bounds UVs' feature to bake the tiling and scale the UVs to fit in the 0,0 .. 1,1 rectangle.\n");
sb.AppendFormat(" 3) Use the Multiple Materials feature to map the material on this submesh to its own submesh in the combined mesh. No other materials should map to this submesh. This will result in only one texture in the atlas(es) and the UVs should tile correctly.\n");
sb.AppendFormat(" 4) Combine only meshes that use the same (or subset of) the set of materials on this mesh. The original material(s) can be applied to the result\n");
}
}
if (mar[0].hasOverlappingSubmeshVerts)
{
sb.AppendFormat("\nObject {0} has submeshes that share vertices. This is a problem because each vertex can have only one UV coordinate and may be required to map to different positions in the various atlases that are generated. Possible treatments:\n", objsToMesh[i]);
sb.AppendFormat(" 1) Ignore the problem. The vertices may not affect the result.\n");
sb.AppendFormat(" 2) Use the Multiple Materials feature to map the submeshs that overlap to their own submeshs in the combined mesh. No other materials should map to this submesh. This will result in only one texture in the atlas(es) and the UVs should tile correctly.\n");
sb.AppendFormat(" 3) Combine only meshes that use the same (or subset of) the set of materials on this mesh. The original material(s) can be applied to the result\n");
}
}
Dictionary <Material, List <GameObject> > m2gos = new Dictionary <Material, List <GameObject> >();
for (int i = 0; i < objsToMesh.Count; i++)
{
if (objsToMesh[i] != null)
{
Material[] ms = MB_Utility.GetGOMaterials(objsToMesh[i]);
for (int j = 0; j < ms.Length; j++)
{
if (ms[j] != null)
{
List <GameObject> lgo;
if (!m2gos.TryGetValue(ms[j], out lgo))
{
lgo = new List <GameObject>();
m2gos.Add(ms[j], lgo);
}
if (!lgo.Contains(objsToMesh[i]))
{
lgo.Add(objsToMesh[i]);
}
}
}
}
}
for (int i = 0; i < resultMaterials.Length; i++)
{
string resultMatShaderName = resultMaterials[i] != null ? "None" : resultMaterials[i].shader.name;
MB3_TextureCombinerPipeline.TexturePipelineData data = LoadPipelineData(resultMaterials[i], new List <ShaderTextureProperty>(), objsToMesh, new List <Material>(), new List <MB_TexSet>());
MB3_TextureCombinerPipeline._CollectPropertyNames(data, LOG_LEVEL);
foreach (Material m in m2gos.Keys)
{
for (int j = 0; j < data.texPropertyNames.Count; j++)
{
if (m.HasProperty(data.texPropertyNames[j].name))
{
Texture txx = MB3_TextureCombinerPipeline.GetTextureConsideringStandardShaderKeywords(resultMatShaderName, m, data.texPropertyNames[j].name);
if (txx != null)
{
Vector2 o = m.GetTextureOffset(data.texPropertyNames[j].name);
Vector3 s = m.GetTextureScale(data.texPropertyNames[j].name);
if (o.x < 0f || o.x + s.x > 1f ||
o.y < 0f || o.y + s.y > 1f)
{
sb.AppendFormat("\nMaterial {0} used by objects {1} uses texture {2} that is tiled (scale={3} offset={4}). If there is more than one texture in the atlas " +
" then Mesh Baker will bake the tiling into the atlas. If the baked tiling is large then quality can be lost. Possible treatments:\n", m, PrintList(m2gos[m]), txx, s, o);
sb.AppendFormat(" 1) Use the baked tiling.\n");
sb.AppendFormat(" 2) Use the Multiple Materials feature to map the material on this object/submesh to its own submesh in the combined mesh. No other materials should map to this submesh. The original material can be applied to this submesh.\n");
sb.AppendFormat(" 3) Combine only meshes that use the same (or subset of) the set of textures on this mesh. The original material can be applied to the result.\n");
}
}
}
}
}
}
string outstr = "";
if (sb.Length == 0)
{
outstr = "====== No problems detected. These meshes should combine well ====\n If there are problems with the combined meshes please report the problem to digitalOpus.ca so we can improve Mesh Baker.";
}
else
{
outstr = "====== There are possible problems with these meshes that may prevent them from combining well. TREATMENT SUGGESTIONS (copy and paste to text editor if too big) =====\n" + sb.ToString();
}
Debug.Log(outstr);
}
public GameObjectFilterInfo(GameObject g, HashSet <GameObject> objsAlreadyInBakers, IGroupByFilter[] filts)
{
go = g;
Renderer r = MB_Utility.GetRenderer(g);
//material = r.sharedMaterial;
//if (material != null) shader = material.shader;
HashSet <Material> matsSet = new HashSet <Material>();
HashSet <Shader> shaderSet = new HashSet <Shader>();
if (r is SkinnedMeshRenderer)
{
isMeshRenderer = false;
}
else
{
isMeshRenderer = true;
}
materials = r.sharedMaterials;
//shaders = new Shader[materials.Length];
for (int i = 0; i < materials.Length; i++)
{
if (materials[i] != null)
{
matsSet.Add(materials[i]);
shaderSet.Add(materials[i].shader);
}
}
materials = new Material[matsSet.Count];
matsSet.CopyTo(materials);
shaders = new Shader[shaderSet.Count];
standardShaderBlendModes = new StandardShaderBlendMode[matsSet.Count];
shaderSet.CopyTo(shaders);
Array.Sort(materials, new NameComparer());
Array.Sort(shaders, new NameComparer());
List <string> standardShaderBlendModesNameSet = new List <string>();
for (int i = 0; i < materials.Length; i++)
{
if (materials[i].shader.name.StartsWith("Standard") && materials[i].HasProperty("_Mode"))
{
standardShaderBlendModes[i] = (StandardShaderBlendMode)materials[i].GetFloat("_Mode");
}
else
{
standardShaderBlendModes[i] = StandardShaderBlendMode.NotApplicable;
}
if (!standardShaderBlendModesNameSet.Contains(standardShaderBlendModes[i].ToString()))
{
standardShaderBlendModesNameSet.Add(standardShaderBlendModes[i].ToString());
}
materialName += (materials[i] == null ? "null" : materials[i].name);
if (i < materials.Length - 1)
{
materialName += ",";
}
}
standardShaderBlendModesName = "";
standardShaderBlendModesNameSet.Sort();
foreach (string modeName in standardShaderBlendModesNameSet)
{
standardShaderBlendModesName += modeName + ",";
}
for (int i = 0; i < shaders.Length; i++)
{
shaderName += (shaders[i] == null ? "null" : shaders[i].name);
if (i < shaders.Length - 1)
{
shaderName += ",";
}
}
lightmapIndex = r.lightmapIndex;
Mesh mesh = MB_Utility.GetMesh(g);
numVerts = 0;
if (mesh != null)
{
numVerts = mesh.vertexCount;
}
isStatic = go.isStatic;
numMaterials = materials.Length;
warning = "";
alreadyInBakerList = objsAlreadyInBakers.Contains(g);
outOfBoundsUVs = false;
submeshesOverlap = false;
filters = filts;
}
void _distributeAmongBakers(UnityEngine.GameObject[] gos, UnityEngine.GameObject[] deleteGOs)
{
if (gos == null)
{
gos = empty;
}
if (deleteGOs == null)
{
deleteGOs = empty;
}
if (resultSceneObject == null)
{
resultSceneObject = new UnityEngine.GameObject("CombinedMesh-" + name);
}
//PART 2 ==== calculate which bakers to add objects to
for (int i = 0; i < meshCombiners.Count; i++)
{
meshCombiners[i].extraSpace = _maxVertsInMesh - meshCombiners[i].combinedMesh.GetMesh().vertexCount;
}
//Profile.EndProfile("MB2_MultiMeshCombiner.AddDeleteGameObjects1");
//Profile.StartProfile("MB2_MultiMeshCombiner.AddDeleteGameObjects2.1");
//first delete game objects from the existing combinedMeshes keep track of free space
for (int i = 0; i < deleteGOs.Length; i++)
{
CombinedMesh c = null;
if (obj2MeshCombinerMap.TryGetValue(deleteGOs[i], out c))
{
if (VERBOSE)
{
Debug.Log("Removing " + deleteGOs[i] + " from meshCombiner " + meshCombiners.IndexOf(c));
}
c.numVertsInListToDelete += c.combinedMesh.GetNumVerticesFor(deleteGOs[i]); //m.vertexCount;
c.gosToDelete.Add(deleteGOs[i]);
}
else
{
Debug.LogWarning("UnityEngine.Object " + deleteGOs[i] + " in the list of objects to delete is not in the combined mesh.");
}
}
for (int i = 0; i < gos.Length; i++)
{
UnityEngine.GameObject go = gos[i];
int numVerts = MB_Utility.GetMesh(go).vertexCount;
CombinedMesh cm = null;
for (int j = 0; j < meshCombiners.Count; j++)
{
if (meshCombiners[j].extraSpace + meshCombiners[j].numVertsInListToDelete - meshCombiners[j].numVertsInListToAdd > numVerts)
{
cm = meshCombiners[j];
if (VERBOSE)
{
Debug.Log("Added " + gos[i] + " to combinedMesh " + j);
}
break;
}
}
if (cm == null)
{
cm = new CombinedMesh(maxVertsInMesh);
_setMBValues(cm.combinedMesh);
meshCombiners.Add(cm);
if (VERBOSE)
{
Debug.Log("Created new combinedMesh");
}
}
cm.gosToAdd.Add(go);
cm.numVertsInListToAdd += numVerts;
// obj2MeshCombinerMap.Add(go,cm);
}
}
//posibilities
// using fixOutOfBoundsUVs or not
//
public static void ConfigureMutiMaterialsFromObjsToCombine(MB3_TextureBaker mom, SerializedProperty resultMaterials, SerializedObject textureBaker)
{
if (mom.GetObjectsToCombine().Count == 0)
{
Debug.LogError("You need to add some objects to combine before building the multi material list.");
return;
}
if (resultMaterials.arraySize > 0)
{
Debug.LogError("You already have some source to combined material mappings configured. You must remove these before doing this operation.");
return;
}
if (mom.textureBakeResults == null)
{
Debug.LogError("Texture Bake Result asset must be set before using this operation.");
return;
}
Dictionary <MultiMatSubmeshInfo, List <List <Material> > > shader2Material_map = new Dictionary <MultiMatSubmeshInfo, List <List <Material> > >();
Dictionary <Material, Mesh> obUVobject2mesh_map = new Dictionary <Material, Mesh>();
//validate that the objects to be combined are valid
for (int i = 0; i < mom.GetObjectsToCombine().Count; i++)
{
GameObject go = mom.GetObjectsToCombine()[i];
if (go == null)
{
Debug.LogError("Null object in list of objects to combine at position " + i);
return;
}
Renderer r = go.GetComponent <Renderer>();
if (r == null || (!(r is MeshRenderer) && !(r is SkinnedMeshRenderer)))
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine did not have a renderer");
return;
}
if (r.sharedMaterial == null)
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine has a null material");
return;
}
}
//first pass put any meshes with obUVs on their own submesh if not fixing OB uvs
if (mom.doMultiMaterialSplitAtlasesIfOBUVs)
{
for (int i = 0; i < mom.GetObjectsToCombine().Count; i++)
{
GameObject go = mom.GetObjectsToCombine()[i];
Mesh m = MB_Utility.GetMesh(go);
MB_Utility.MeshAnalysisResult dummyMar = new MB_Utility.MeshAnalysisResult();
Renderer r = go.GetComponent <Renderer>();
for (int j = 0; j < r.sharedMaterials.Length; j++)
{
if (MB_Utility.hasOutOfBoundsUVs(m, ref dummyMar, j))
{
if (!obUVobject2mesh_map.ContainsKey(r.sharedMaterials[j]))
{
Debug.LogWarning("Object " + go + " submesh " + j + " uses UVs outside the range 0,0..1,1 to generate tiling. This object has been mapped to its own submesh in the combined mesh. It can share a submesh with other objects that use different materials if you use the fix out of bounds UVs feature which will bake the tiling");
obUVobject2mesh_map.Add(r.sharedMaterials[j], m);
}
}
}
}
}
//second pass put other materials without OB uvs in a shader to material map
for (int i = 0; i < mom.GetObjectsToCombine().Count; i++)
{
Renderer r = mom.GetObjectsToCombine()[i].GetComponent <Renderer>();
for (int j = 0; j < r.sharedMaterials.Length; j++)
{
if (!obUVobject2mesh_map.ContainsKey(r.sharedMaterials[j]))
{ //if not already added
if (r.sharedMaterials[j] == null)
{
continue;
}
List <List <Material> > binsOfMatsThatUseShader = null;
MultiMatSubmeshInfo newKey = new MultiMatSubmeshInfo(r.sharedMaterials[j].shader, r.sharedMaterials[j]);
if (!shader2Material_map.TryGetValue(newKey, out binsOfMatsThatUseShader))
{
binsOfMatsThatUseShader = new List <List <Material> >();
binsOfMatsThatUseShader.Add(new List <Material>());
shader2Material_map.Add(newKey, binsOfMatsThatUseShader);
}
if (!binsOfMatsThatUseShader[0].Contains(r.sharedMaterials[j]))
{
binsOfMatsThatUseShader[0].Add(r.sharedMaterials[j]);
}
}
}
}
int numResMats = shader2Material_map.Count;
//third pass for each shader grouping check how big the atlas would be and group into bins that would fit in an atlas
if (mom.doMultiMaterialSplitAtlasesIfTooBig)
{
if (mom.packingAlgorithm == MB2_PackingAlgorithmEnum.UnitysPackTextures)
{
Debug.LogWarning("Unity texture packer does not support splitting atlases if too big. Atlases will not be split.");
}
else
{
numResMats = 0;
foreach (MultiMatSubmeshInfo sh in shader2Material_map.Keys)
{
List <List <Material> > binsOfMatsThatUseShader = shader2Material_map[sh];
List <Material> allMatsThatUserShader = binsOfMatsThatUseShader[0];//at this point everything is in the same list
binsOfMatsThatUseShader.RemoveAt(0);
MB3_TextureCombiner combiner = mom.CreateAndConfigureTextureCombiner();
combiner.saveAtlasesAsAssets = false;
if (allMatsThatUserShader.Count > 1)
{
combiner.fixOutOfBoundsUVs = mom.fixOutOfBoundsUVs;
}
else
{
combiner.fixOutOfBoundsUVs = false;
}
// Do the texture pack
List <AtlasPackingResult> packingResults = new List <AtlasPackingResult>();
Material tempMat = new Material(sh.shader);
combiner.CombineTexturesIntoAtlases(null, null, tempMat, mom.GetObjectsToCombine(), allMatsThatUserShader, null, packingResults, true);
for (int i = 0; i < packingResults.Count; i++)
{
List <MatsAndGOs> matsData = (List <MatsAndGOs>)packingResults[i].data;
List <Material> mats = new List <Material>();
for (int j = 0; j < matsData.Count; j++)
{
for (int kk = 0; kk < matsData[j].mats.Count; kk++)
{
if (!mats.Contains(matsData[j].mats[kk].mat))
{
mats.Add(matsData[j].mats[kk].mat);
}
}
}
binsOfMatsThatUseShader.Add(mats);
}
numResMats += binsOfMatsThatUseShader.Count;
}
}
}
//build the result materials
if (shader2Material_map.Count == 0 && obUVobject2mesh_map.Count == 0)
{
Debug.LogError("Found no materials in list of objects to combine");
}
mom.resultMaterials = new MB_MultiMaterial[numResMats + obUVobject2mesh_map.Count];
string pth = AssetDatabase.GetAssetPath(mom.textureBakeResults);
string baseName = Path.GetFileNameWithoutExtension(pth);
string folderPath = pth.Substring(0, pth.Length - baseName.Length - 6);
int k = 0;
foreach (MultiMatSubmeshInfo sh in shader2Material_map.Keys)
{
foreach (List <Material> matsThatUse in shader2Material_map[sh])
{
MB_MultiMaterial mm = mom.resultMaterials[k] = new MB_MultiMaterial();
mm.sourceMaterials = matsThatUse;
if (mm.sourceMaterials.Count == 1)
{
mm.considerMeshUVs = false;
}
else
{
mm.considerMeshUVs = mom.fixOutOfBoundsUVs;
}
string matName = folderPath + baseName + "-mat" + k + ".mat";
Material newMat = new Material(Shader.Find("Diffuse"));
if (matsThatUse.Count > 0 && matsThatUse[0] != null)
{
MB3_TextureBaker.ConfigureNewMaterialToMatchOld(newMat, matsThatUse[0]);
}
AssetDatabase.CreateAsset(newMat, matName);
mm.combinedMaterial = (Material)AssetDatabase.LoadAssetAtPath(matName, typeof(Material));
k++;
}
}
foreach (Material m in obUVobject2mesh_map.Keys)
{
MB_MultiMaterial mm = mom.resultMaterials[k] = new MB_MultiMaterial();
mm.sourceMaterials = new List <Material>();
mm.sourceMaterials.Add(m);
mm.considerMeshUVs = false;
string matName = folderPath + baseName + "-mat" + k + ".mat";
Material newMat = new Material(Shader.Find("Diffuse"));
MB3_TextureBaker.ConfigureNewMaterialToMatchOld(newMat, m);
AssetDatabase.CreateAsset(newMat, matName);
mm.combinedMaterial = (Material)AssetDatabase.LoadAssetAtPath(matName, typeof(Material));
k++;
}
MBVersionEditor.UpdateIfDirtyOrScript(textureBaker);
}
/* tried to see if the MultiMaterialConfig could be done using the GroupBy filters. Saddly it didn't work */
public static void ConfigureMutiMaterialsFromObjsToCombine2(MB3_TextureBaker mom, SerializedProperty resultMaterials, SerializedObject textureBaker)
{
if (mom.GetObjectsToCombine().Count == 0)
{
Debug.LogError("You need to add some objects to combine before building the multi material list.");
return;
}
if (resultMaterials.arraySize > 0)
{
Debug.LogError("You already have some source to combined material mappings configured. You must remove these before doing this operation.");
return;
}
if (mom.textureBakeResults == null)
{
Debug.LogError("Texture Bake Result asset must be set before using this operation.");
return;
}
//validate that the objects to be combined are valid
for (int i = 0; i < mom.GetObjectsToCombine().Count; i++)
{
GameObject go = mom.GetObjectsToCombine()[i];
if (go == null)
{
Debug.LogError("Null object in list of objects to combine at position " + i);
return;
}
Renderer r = go.GetComponent <Renderer>();
if (r == null || (!(r is MeshRenderer) && !(r is SkinnedMeshRenderer)))
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine did not have a renderer");
return;
}
if (r.sharedMaterial == null)
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine has a null material");
return;
}
}
IGroupByFilter[] filters = new IGroupByFilter[3];
filters[0] = new GroupByOutOfBoundsUVs();
filters[1] = new GroupByShader();
filters[2] = new MB3_GroupByStandardShaderType();
List <GameObjectFilterInfo> gameObjects = new List <GameObjectFilterInfo>();
HashSet <GameObject> objectsAlreadyIncludedInBakers = new HashSet <GameObject>();
for (int i = 0; i < mom.GetObjectsToCombine().Count; i++)
{
GameObjectFilterInfo goaw = new GameObjectFilterInfo(mom.GetObjectsToCombine()[i], objectsAlreadyIncludedInBakers, filters);
if (goaw.materials.Length > 0) //don't consider renderers with no materials
{
gameObjects.Add(goaw);
}
}
//analyse meshes
Dictionary <int, MB_Utility.MeshAnalysisResult> meshAnalysisResultCache = new Dictionary <int, MB_Utility.MeshAnalysisResult>();
int totalVerts = 0;
for (int i = 0; i < gameObjects.Count; i++)
{
//string rpt = String.Format("Processing {0} [{1} of {2}]", gameObjects[i].go.name, i, gameObjects.Count);
//EditorUtility.DisplayProgressBar("Analysing Scene", rpt + " A", .6f);
Mesh mm = MB_Utility.GetMesh(gameObjects[i].go);
int nVerts = 0;
if (mm != null)
{
nVerts += mm.vertexCount;
MB_Utility.MeshAnalysisResult mar;
if (!meshAnalysisResultCache.TryGetValue(mm.GetInstanceID(), out mar))
{
//EditorUtility.DisplayProgressBar("Analysing Scene", rpt + " Check Out Of Bounds UVs", .6f);
MB_Utility.hasOutOfBoundsUVs(mm, ref mar);
//Rect dummy = mar.uvRect;
MB_Utility.doSubmeshesShareVertsOrTris(mm, ref mar);
meshAnalysisResultCache.Add(mm.GetInstanceID(), mar);
}
if (mar.hasOutOfBoundsUVs)
{
int w = (int)mar.uvRect.width;
int h = (int)mar.uvRect.height;
gameObjects[i].outOfBoundsUVs = true;
gameObjects[i].warning += " [WARNING: has uvs outside the range (0,1) tex is tiled " + w + "x" + h + " times]";
}
if (mar.hasOverlappingSubmeshVerts)
{
gameObjects[i].submeshesOverlap = true;
gameObjects[i].warning += " [WARNING: Submeshes share verts or triangles. 'Multiple Combined Materials' feature may not work.]";
}
}
totalVerts += nVerts;
//EditorUtility.DisplayProgressBar("Analysing Scene", rpt + " Validate OBuvs Multi Material", .6f);
Renderer mr = gameObjects[i].go.GetComponent <Renderer>();
if (!MB_Utility.AreAllSharedMaterialsDistinct(mr.sharedMaterials))
{
gameObjects[i].warning += " [WARNING: Object uses same material on multiple submeshes. This may produce poor results when used with multiple materials or fix out of bounds uvs.]";
}
}
List <GameObjectFilterInfo> objsNotAddedToBaker = new List <GameObjectFilterInfo>();
Dictionary <GameObjectFilterInfo, List <List <GameObjectFilterInfo> > > gs2bakeGroupMap = MB3_MeshBakerEditorWindow.sortIntoBakeGroups3(gameObjects, objsNotAddedToBaker, filters, false, mom.maxAtlasSize);
mom.resultMaterials = new MB_MultiMaterial[gs2bakeGroupMap.Keys.Count];
string pth = AssetDatabase.GetAssetPath(mom.textureBakeResults);
string baseName = Path.GetFileNameWithoutExtension(pth);
string folderPath = pth.Substring(0, pth.Length - baseName.Length - 6);
int k = 0;
foreach (GameObjectFilterInfo m in gs2bakeGroupMap.Keys)
{
MB_MultiMaterial mm = mom.resultMaterials[k] = new MB_MultiMaterial();
mm.sourceMaterials = new List <Material>();
mm.sourceMaterials.Add(m.materials[0]);
string matName = folderPath + baseName + "-mat" + k + ".mat";
Material newMat = new Material(Shader.Find("Diffuse"));
MB3_TextureBaker.ConfigureNewMaterialToMatchOld(newMat, m.materials[0]);
AssetDatabase.CreateAsset(newMat, matName);
mm.combinedMaterial = (Material)AssetDatabase.LoadAssetAtPath(matName, typeof(Material));
k++;
}
MBVersionEditor.UpdateIfDirtyOrScript(textureBaker);
}
public static Mesh BakeMeshesInPlace(MB2_MeshCombiner mom, List <GameObject> objsToMesh, string saveFolder, ProgressUpdateDelegate updateProgressBar)
{
if (MB2_MeshCombiner.EVAL_VERSION)
{
return(null);
}
Mesh mesh;
if (!Directory.Exists(Application.dataPath + saveFolder.Substring(6, saveFolder.Length - 6)))
{
Debug.Log((Application.dataPath + saveFolder));
Debug.Log(Path.GetFullPath(Application.dataPath + saveFolder));
Debug.LogError("The selected Folder For Meshes does not exist or is not inside the projects Assets folder. Please 'Choose Folder For Bake In Place Meshes' that is inside the project's assets folder.");
return(null);
}
MB2_EditorMethods editorMethods = new MB2_EditorMethods();
mom.DestroyMeshEditor(editorMethods);
GameObject[] objs = new GameObject[1];
MB_RenderType originalRenderType = mom.renderType;
Mesh outMesh = null;
for (int i = 0; i < objsToMesh.Count; i++)
{
if (objsToMesh[i] == null)
{
Debug.LogError("The " + i + "th object on the list of objects to combine is 'None'. Use Command-Delete on Mac OS X; Delete or Shift-Delete on Windows to remove this one element.");
return(null);
}
string[] objNames = GenerateNames(objsToMesh);
objs[0] = objsToMesh[i];
Renderer r = MB_Utility.GetRenderer(objsToMesh[i]);
if (r is SkinnedMeshRenderer)
{
mom.renderType = MB_RenderType.skinnedMeshRenderer;
}
else
{
mom.renderType = MB_RenderType.meshRenderer;
}
mesh = mom.AddDeleteGameObjects(objs, null, false);
if (mesh != null)
{
mom.Apply();
Mesh mf = MB_Utility.GetMesh(objs[0]);
if (mf != null)
{
string newFilename = saveFolder + "/" + objNames[i];
if (updateProgressBar != null)
{
updateProgressBar("Created mesh saving mesh on " + objs[0].name + " to asset " + newFilename, .6f);
}
if (newFilename != null && newFilename.Length != 0)
{
Debug.Log("Creating mesh for " + objs[0].name + " with adjusted UVs at: " + newFilename);
AssetDatabase.CreateAsset(mesh, newFilename);
outMesh = (Mesh)AssetDatabase.LoadAssetAtPath(newFilename, typeof(Mesh));
}
else
{
Debug.LogWarning("Could not save mesh for " + objs[0].name);
}
}
}
mom.DestroyMeshEditor(editorMethods);
}
mom.renderType = originalRenderType;
return(outMesh);
}
public static void BakeMeshesInPlace(MB2_MeshCombiner mom, List <UnityEngine.GameObject> objsToMesh, ProgressUpdateDelegate updateProgressBar)
{
#if UNITY_EDITOR
Mesh mesh;
// if (!MB_Utility.doCombinedValidate(mom, MB_ObjsToCombineTypes.prefabOnly)) return;
// List<UnityEngine.GameObject> objsToMesh = mom.objsToMesh;
// if (mom.useObjsToMeshFromTexBaker && mom.GetComponent<MB2_TextureBaker>() != null){
// objsToMesh = mom.GetComponent<MB2_TextureBaker>().objsToMesh;
// }
mom.DestroyMesh();
UnityEngine.GameObject[] objs = new UnityEngine.GameObject[1];
List <string> usedNames = new List <string>();
MB_RenderType originalRenderType = mom.renderType;
for (int i = 0; i < objsToMesh.Count; i++)
{
if (objsToMesh[i] == null)
{
Debug.LogError("The " + i + "th object on the list of objects to combine is 'None'. Use Command-Delete on Mac OS X; Delete or Shift-Delete on Windows to remove this one element.");
return;
}
objs[0] = objsToMesh[i];
UnityEngine.Renderer r = MB_Utility.GetRenderer(objsToMesh[i]);
if (r is SkinnedMeshRenderer)
{
mom.renderType = MB_RenderType.skinnedMeshRenderer;
}
else
{
mom.renderType = MB_RenderType.meshRenderer;
}
mesh = mom.AddDeleteGameObjects(objs, null, false);
if (mesh != null)
{
//mom.ApplyAll();
mom.Apply();
Mesh mf = MB_Utility.GetMesh(objs[0]);
if (mf != null)
{
string baseName, folderPath, newFilename;
string pth = AssetDatabase.GetAssetPath(mf);
if (pth != null && pth.Length != 0)
{
baseName = Path.GetFileNameWithoutExtension(pth) + "_" + objs[0].name + "_MB";
folderPath = Path.GetDirectoryName(pth);
}
else //try to get the name from prefab
{
pth = AssetDatabase.GetAssetPath(objs[0]); //get prefab name
if (pth != null && pth.Length != 0)
{
baseName = Path.GetFileNameWithoutExtension(pth) + "_" + objs[0].name + "_MB";
folderPath = Path.GetDirectoryName(pth);
}
else //save in root
{
baseName = objs[0].name + "mesh_MB";
folderPath = "Assets";
}
}
//make name unique
newFilename = Path.Combine(folderPath, baseName + ".asset");
int j = 0;
while (usedNames.Contains(newFilename))
{
newFilename = Path.Combine(folderPath, baseName + j + ".asset");
j++;
}
usedNames.Add(newFilename);
updateProgressBar("Created mesh saving mesh on " + objs[0].name + " to asset " + newFilename, .6f);
if (newFilename != null && newFilename.Length != 0)
{
Debug.Log("Creating mesh for " + objs[0].name + " with adjusted UVs at: " + newFilename);
AssetDatabase.CreateAsset(mesh, newFilename);
}
else
{
Debug.LogWarning("Could not save mesh for " + objs[0].name);
}
}
}
mom.DestroyMesh();
}
mom.renderType = originalRenderType;
#endif
}
public void ConfigureMutiMaterialsFromObjsToCombine(MB3_TextureBaker mom)
{
if (mom.objsToMesh.Count == 0)
{
Debug.LogError("You need to add some objects to combine before building the multi material list.");
return;
}
if (resultMaterials.arraySize > 0)
{
Debug.LogError("You already have some source to combined material mappings configured. You must remove these before doing this operation.");
return;
}
if (mom.textureBakeResults == null)
{
Debug.LogError("Material Bake Result asset must be set before using this operation.");
return;
}
Dictionary <Shader, List <Material> > shader2Material_map = new Dictionary <Shader, List <Material> >();
Dictionary <Material, Mesh> obUVobject2material_map = new Dictionary <Material, Mesh>();
//validate that the objects to be combined are valid
for (int i = 0; i < mom.objsToMesh.Count; i++)
{
GameObject go = mom.objsToMesh[i];
if (go == null)
{
Debug.LogError("Null object in list of objects to combine at position " + i);
return;
}
Renderer r = go.GetComponent <Renderer>();
if (r == null || (!(r is MeshRenderer) && !(r is SkinnedMeshRenderer)))
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine did not have a renderer");
return;
}
if (r.sharedMaterial == null)
{
Debug.LogError("GameObject at position " + i + " in list of objects to combine has a null material");
return;
}
}
//first pass put any meshes with obUVs on their own submesh if not fixing OB uvs
if (!mom.fixOutOfBoundsUVs)
{
for (int i = 0; i < mom.objsToMesh.Count; i++)
{
GameObject go = mom.objsToMesh[i];
Mesh m = MB_Utility.GetMesh(go);
Rect dummy = new Rect();
Renderer r = go.GetComponent <Renderer>();
for (int j = 0; j < r.sharedMaterials.Length; j++)
{
if (MB_Utility.hasOutOfBoundsUVs(m, ref dummy, j))
{
if (!obUVobject2material_map.ContainsKey(r.sharedMaterials[j]))
{
Debug.LogWarning("Object " + go + " submesh " + j + " uses UVs outside the range 0,0..1,1 to generate tiling. This object has been mapped to its own submesh in the combined mesh. It can share a submesh with other objects that use different materials if you use the fix out of bounds UVs feature which will bake the tiling");
obUVobject2material_map.Add(r.sharedMaterials[j], m);
}
}
}
}
}
//second pass put other materials without OB uvs in a shader to material map
for (int i = 0; i < mom.objsToMesh.Count; i++)
{
Renderer r = mom.objsToMesh[i].GetComponent <Renderer>();
for (int j = 0; j < r.sharedMaterials.Length; j++)
{
if (!obUVobject2material_map.ContainsKey(r.sharedMaterials[j]))
{
if (r.sharedMaterials[j] == null)
{
continue;
}
List <Material> matsThatUseShader = null;
if (!shader2Material_map.TryGetValue(r.sharedMaterials[j].shader, out matsThatUseShader))
{
matsThatUseShader = new List <Material>();
shader2Material_map.Add(r.sharedMaterials[j].shader, matsThatUseShader);
}
if (!matsThatUseShader.Contains(r.sharedMaterials[j]))
{
matsThatUseShader.Add(r.sharedMaterials[j]);
}
}
}
}
if (shader2Material_map.Count == 0 && obUVobject2material_map.Count == 0)
{
Debug.LogError("Found no materials in list of objects to combine");
}
mom.resultMaterials = new MB_MultiMaterial[shader2Material_map.Count + obUVobject2material_map.Count];
string pth = AssetDatabase.GetAssetPath(mom.textureBakeResults);
string baseName = Path.GetFileNameWithoutExtension(pth);
string folderPath = pth.Substring(0, pth.Length - baseName.Length - 6);
int k = 0;
foreach (Shader sh in shader2Material_map.Keys)
{
List <Material> matsThatUse = shader2Material_map[sh];
MB_MultiMaterial mm = mom.resultMaterials[k] = new MB_MultiMaterial();
mm.sourceMaterials = matsThatUse;
string matName = folderPath + baseName + "-mat" + k + ".mat";
Material newMat = new Material(Shader.Find("Diffuse"));
if (matsThatUse.Count > 0 && matsThatUse[0] != null)
{
MB3_TextureBaker.ConfigureNewMaterialToMatchOld(newMat, matsThatUse[0]);
}
AssetDatabase.CreateAsset(newMat, matName);
mm.combinedMaterial = (Material)AssetDatabase.LoadAssetAtPath(matName, typeof(Material));
k++;
}
foreach (Material m in obUVobject2material_map.Keys)
{
MB_MultiMaterial mm = mom.resultMaterials[k] = new MB_MultiMaterial();
mm.sourceMaterials = new List <Material>();
mm.sourceMaterials.Add(m);
string matName = folderPath + baseName + "-mat" + k + ".mat";
Material newMat = new Material(Shader.Find("Diffuse"));
MB3_TextureBaker.ConfigureNewMaterialToMatchOld(newMat, m);
AssetDatabase.CreateAsset(newMat, matName);
mm.combinedMaterial = (Material)AssetDatabase.LoadAssetAtPath(matName, typeof(Material));
k++;
}
textureBaker.UpdateIfDirtyOrScript();
}
private void _distributeAmongBakers(GameObject[] gos, int[] deleteGOinstanceIDs)
{
if (gos == null)
{
gos = MB3_MultiMeshCombiner.empty;
}
if (deleteGOinstanceIDs == null)
{
deleteGOinstanceIDs = MB3_MultiMeshCombiner.emptyIDs;
}
if (this.resultSceneObject == null)
{
this.resultSceneObject = new GameObject("CombinedMesh-" + base.name);
}
for (int i = 0; i < this.meshCombiners.Count; i++)
{
this.meshCombiners[i].extraSpace = this._maxVertsInMesh - this.meshCombiners[i].combinedMesh.GetMesh().vertexCount;
}
for (int j = 0; j < deleteGOinstanceIDs.Length; j++)
{
MB3_MultiMeshCombiner.CombinedMesh combinedMesh = null;
if (this.obj2MeshCombinerMap.TryGetValue(deleteGOinstanceIDs[j], out combinedMesh))
{
if (this.LOG_LEVEL >= MB2_LogLevel.debug)
{
MB2_Log.LogDebug(string.Concat(new object[]
{
"MB2_MultiMeshCombiner.Removing ",
deleteGOinstanceIDs[j],
" from meshCombiner ",
this.meshCombiners.IndexOf(combinedMesh)
}), new object[0]);
}
combinedMesh.numVertsInListToDelete += combinedMesh.combinedMesh.GetNumVerticesFor(deleteGOinstanceIDs[j]);
combinedMesh.gosToDelete.Add(deleteGOinstanceIDs[j]);
}
else
{
Debug.LogWarning("Object " + deleteGOinstanceIDs[j] + " in the list of objects to delete is not in the combined mesh.");
}
}
for (int k = 0; k < gos.Length; k++)
{
GameObject gameObject = gos[k];
int vertexCount = MB_Utility.GetMesh(gameObject).vertexCount;
MB3_MultiMeshCombiner.CombinedMesh combinedMesh2 = null;
for (int l = 0; l < this.meshCombiners.Count; l++)
{
if (this.meshCombiners[l].extraSpace + this.meshCombiners[l].numVertsInListToDelete - this.meshCombiners[l].numVertsInListToAdd > vertexCount)
{
combinedMesh2 = this.meshCombiners[l];
if (this.LOG_LEVEL >= MB2_LogLevel.debug)
{
MB2_Log.LogDebug(string.Concat(new object[]
{
"MB2_MultiMeshCombiner.Added ",
gos[k],
" to combinedMesh ",
l
}), new object[]
{
this.LOG_LEVEL
});
}
break;
}
}
if (combinedMesh2 == null)
{
combinedMesh2 = new MB3_MultiMeshCombiner.CombinedMesh(this.maxVertsInMesh, this._resultSceneObject, this._LOG_LEVEL);
this._setMBValues(combinedMesh2.combinedMesh);
this.meshCombiners.Add(combinedMesh2);
if (this.LOG_LEVEL >= MB2_LogLevel.debug)
{
MB2_Log.LogDebug("MB2_MultiMeshCombiner.Created new combinedMesh", new object[0]);
}
}
combinedMesh2.gosToAdd.Add(gameObject);
combinedMesh2.numVertsInListToAdd += vertexCount;
}
}
public GameObjectFilterInfo(GameObject g, HashSet <GameObject> objsAlreadyInBakers)
{
go = g;
Renderer r = MB_Utility.GetRenderer(g);
//material = r.sharedMaterial;
//if (material != null) shader = material.shader;
HashSet <Material> matsSet = new HashSet <Material>();
HashSet <Shader> shaderSet = new HashSet <Shader>();
if (r is SkinnedMeshRenderer)
{
isMeshRenderer = false;
}
else
{
isMeshRenderer = true;
}
materials = r.sharedMaterials;
//shaders = new Shader[materials.Length];
for (int i = 0; i < materials.Length; i++)
{
if (materials[i] != null)
{
matsSet.Add(materials[i]);
shaderSet.Add(materials[i].shader);
}
}
materials = new Material[matsSet.Count];
matsSet.CopyTo(materials);
shaders = new Shader[shaderSet.Count];
shaderSet.CopyTo(shaders);
Array.Sort(materials, new NameComparer());
Array.Sort(shaders, new NameComparer());
for (int i = 0; i < materials.Length; i++)
{
materialName += (materials[i] == null ? "null" : materials[i].name);
if (i < materials.Length - 1)
{
materialName += ",";
}
}
for (int i = 0; i < shaders.Length; i++)
{
shaderName += (shaders[i] == null ? "null" : shaders[i].name);
if (i < shaders.Length - 1)
{
shaderName += ",";
}
}
lightmapIndex = r.lightmapIndex;
Mesh mesh = MB_Utility.GetMesh(g);
numVerts = 0;
if (mesh != null)
{
numVerts = mesh.vertexCount;
}
isStatic = go.isStatic;
numMaterials = materials.Length;
warning = "";
alreadyInBakerList = objsAlreadyInBakers.Contains(g);
outOfBoundsUVs = false;
submeshesOverlap = false;
}