You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
361 lines
13 KiB
361 lines
13 KiB
//----------------------------------------------
|
|
// MeshBaker
|
|
// Copyright © 2011-2012 Ian Deane
|
|
//----------------------------------------------
|
|
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.IO;
|
|
using DigitalOpus.MB.Core;
|
|
using LuaFramework;
|
|
|
|
|
|
/// <summary>
|
|
/// Component that handles baking materials into a combined material.
|
|
///
|
|
/// The result of the material baking process is a MB2_TextureBakeResults object, which
|
|
/// becomes the input for the mesh baking.
|
|
///
|
|
/// This class uses the MB_TextureCombiner to do the combining.
|
|
///
|
|
/// This class is a Component (MonoBehavior) so it is serialized and found using GetComponent. If
|
|
/// you want to access the texture baking functionality without creating a Component then use MB_TextureCombiner
|
|
/// directly.
|
|
/// </summary>
|
|
public class MB3_TextureBaker : MB3_MeshBakerRoot {
|
|
public MB2_LogLevel LOG_LEVEL = MB2_LogLevel.info;
|
|
|
|
[SerializeField] protected MB2_TextureBakeResults _textureBakeResults;
|
|
public override MB2_TextureBakeResults textureBakeResults{
|
|
get{return _textureBakeResults;}
|
|
set{_textureBakeResults = value;}
|
|
}
|
|
|
|
[SerializeField] protected int _atlasPadding = 1;
|
|
public virtual int atlasPadding{
|
|
get{return _atlasPadding;}
|
|
set{_atlasPadding = value;}
|
|
}
|
|
|
|
[SerializeField] protected int _maxAtlasSize = 4096;
|
|
public virtual int maxAtlasSize{
|
|
get{return _maxAtlasSize;}
|
|
set{_maxAtlasSize = value;}
|
|
}
|
|
|
|
[SerializeField] protected bool _resizePowerOfTwoTextures = false;
|
|
public virtual bool resizePowerOfTwoTextures{
|
|
get{return _resizePowerOfTwoTextures;}
|
|
set{_resizePowerOfTwoTextures = value;}
|
|
}
|
|
|
|
[SerializeField] protected bool _fixOutOfBoundsUVs = false;
|
|
public virtual bool fixOutOfBoundsUVs{
|
|
get{return _fixOutOfBoundsUVs;}
|
|
set{_fixOutOfBoundsUVs = value;}
|
|
}
|
|
|
|
[SerializeField] protected int _maxTilingBakeSize = 1024;
|
|
public virtual int maxTilingBakeSize{
|
|
get{return _maxTilingBakeSize;}
|
|
set{_maxTilingBakeSize = value;}
|
|
}
|
|
|
|
[SerializeField] protected MB2_PackingAlgorithmEnum _packingAlgorithm = MB2_PackingAlgorithmEnum.MeshBakerTexturePacker;
|
|
public virtual MB2_PackingAlgorithmEnum packingAlgorithm{
|
|
get{return _packingAlgorithm;}
|
|
set{_packingAlgorithm = value;}
|
|
}
|
|
|
|
[SerializeField] protected bool _meshBakerTexturePackerForcePowerOfTwo = true;
|
|
public bool meshBakerTexturePackerForcePowerOfTwo{
|
|
get{return _meshBakerTexturePackerForcePowerOfTwo;}
|
|
set{_meshBakerTexturePackerForcePowerOfTwo = value;}
|
|
}
|
|
|
|
[SerializeField] protected List<ShaderTextureProperty> _customShaderProperties = new List<ShaderTextureProperty>();
|
|
public virtual List<ShaderTextureProperty> customShaderProperties{
|
|
get{return _customShaderProperties;}
|
|
set{_customShaderProperties = value;}
|
|
}
|
|
|
|
//this is depricated
|
|
[SerializeField] protected List<string> _customShaderPropNames_Depricated = new List<string>();
|
|
public virtual List<string> customShaderPropNames{
|
|
get{return _customShaderPropNames_Depricated;}
|
|
set{_customShaderPropNames_Depricated = value;}
|
|
}
|
|
|
|
[SerializeField] protected bool _doMultiMaterial;
|
|
public virtual bool doMultiMaterial{
|
|
get{return _doMultiMaterial;}
|
|
set{_doMultiMaterial = value;}
|
|
}
|
|
|
|
[SerializeField] protected Material _resultMaterial;
|
|
public virtual Material resultMaterial{
|
|
get{return _resultMaterial;}
|
|
set{_resultMaterial = value;}
|
|
}
|
|
|
|
public MB_MultiMaterial[] resultMaterials = new MB_MultiMaterial[0];
|
|
|
|
public List<GameObject> objsToMesh; //todo make this Renderer
|
|
|
|
public override List<GameObject> GetObjectsToCombine(){
|
|
if (objsToMesh == null) objsToMesh = new List<GameObject>();
|
|
return objsToMesh;
|
|
}
|
|
|
|
public MB_AtlasesAndRects[] CreateAtlases(){
|
|
return CreateAtlases(null, false, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates the atlases.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// The atlases.
|
|
/// </returns>
|
|
/// <param name='progressInfo'>
|
|
/// Progress info is a delegate function that displays a progress dialog. Can be null
|
|
/// </param>
|
|
/// <param name='saveAtlasesAsAssets'>
|
|
/// if true atlases are saved as assets in the project folder. Othersise they are instances in memory
|
|
/// </param>
|
|
/// <param name='editorMethods'>
|
|
/// Texture format tracker. Contains editor functionality such as save assets. Can be null.
|
|
/// </param>
|
|
public MB_AtlasesAndRects[] CreateAtlases(ProgressUpdateDelegate progressInfo, bool saveAtlasesAsAssets = false, MB2_EditorMethodsInterface editorMethods=null){
|
|
MB_AtlasesAndRects[] mAndAs = null;
|
|
try{
|
|
mAndAs = _CreateAtlases(progressInfo, saveAtlasesAsAssets, editorMethods);
|
|
} catch(Exception e){
|
|
Debug.LogError(e);
|
|
} finally {
|
|
if (saveAtlasesAsAssets){ //Atlases were saved to project so we don't need these ones
|
|
if (mAndAs != null){
|
|
for(int j = 0; j < mAndAs.Length; j++){
|
|
MB_AtlasesAndRects mAndA = mAndAs[j];
|
|
if (mAndA != null && mAndA.atlases != null){
|
|
for (int i = 0; i < mAndA.atlases.Length; i++){
|
|
if (mAndA.atlases[i] != null){
|
|
if (editorMethods != null) editorMethods.Destroy(mAndA.atlases[i]);
|
|
else MB_Utility.Destroy(mAndA.atlases[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return mAndAs;
|
|
}
|
|
|
|
MB_AtlasesAndRects[] _CreateAtlases(ProgressUpdateDelegate progressInfo, bool saveAtlasesAsAssets = false, MB2_EditorMethodsInterface editorMethods=null){
|
|
//validation
|
|
if (saveAtlasesAsAssets && editorMethods == null){
|
|
LogManager.LogError("Error in CreateAtlases If saveAtlasesAsAssets = true then editorMethods cannot be null.");
|
|
return null;
|
|
}
|
|
if (saveAtlasesAsAssets && !Application.isEditor){
|
|
LogManager.LogError("Error in CreateAtlases If saveAtlasesAsAssets = true it must be called from the Unity Editor.");
|
|
return null;
|
|
}
|
|
MB2_ValidationLevel vl = Application.isPlaying ? MB2_ValidationLevel.quick : MB2_ValidationLevel.robust;
|
|
if (!DoCombinedValidate(this, MB_ObjsToCombineTypes.dontCare, editorMethods, vl)){
|
|
return null;
|
|
}
|
|
if (_doMultiMaterial && !_ValidateResultMaterials()){
|
|
return null;
|
|
} else if (!_doMultiMaterial){
|
|
if (_resultMaterial == null){
|
|
LogManager.LogError("Combined Material is null please create and assign a result material.");
|
|
return null;
|
|
}
|
|
Shader targShader = _resultMaterial.shader;
|
|
for (int i = 0; i < objsToMesh.Count; i++){
|
|
Material[] ms = MB_Utility.GetGOMaterials(objsToMesh[i]);
|
|
for (int j = 0; j < ms.Length; j++){
|
|
Material m = ms[j];
|
|
if (m != null && m.shader != targShader){
|
|
LogManager.LogWarning("Game object " + objsToMesh[i] + " does not use shader " + targShader + " it may not have the required textures. If not 2x2 clear textures will be generated.");
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < objsToMesh.Count; i++){
|
|
Material[] ms = MB_Utility.GetGOMaterials(objsToMesh[i]);
|
|
for (int j = 0; j < ms.Length; j++){
|
|
Material m = ms[j];
|
|
if (m == null){
|
|
LogManager.LogError("Game object " + objsToMesh[i] + " has a null material. Can't build atlases");
|
|
return null;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
MB3_TextureCombiner combiner = new MB3_TextureCombiner();
|
|
combiner.LOG_LEVEL = LOG_LEVEL;
|
|
combiner.atlasPadding = _atlasPadding;
|
|
combiner.maxAtlasSize = _maxAtlasSize;
|
|
combiner.customShaderPropNames = _customShaderProperties;
|
|
combiner.fixOutOfBoundsUVs = _fixOutOfBoundsUVs;
|
|
combiner.maxTilingBakeSize = _maxTilingBakeSize;
|
|
combiner.packingAlgorithm = _packingAlgorithm;
|
|
combiner.meshBakerTexturePackerForcePowerOfTwo = _meshBakerTexturePackerForcePowerOfTwo;
|
|
combiner.resizePowerOfTwoTextures = _resizePowerOfTwoTextures;
|
|
combiner.saveAtlasesAsAssets = saveAtlasesAsAssets;
|
|
|
|
// if editor analyse meshes and suggest treatment
|
|
if (!Application.isPlaying){
|
|
Material[] rms;
|
|
if (_doMultiMaterial){
|
|
rms = new Material[resultMaterials.Length];
|
|
for (int i = 0; i < rms.Length; i++) rms[i] = resultMaterials[i].combinedMaterial;
|
|
} else {
|
|
rms = new Material[1];
|
|
rms[0] = _resultMaterial;
|
|
}
|
|
combiner.SuggestTreatment(objsToMesh, rms, combiner.customShaderPropNames);
|
|
}
|
|
|
|
//initialize structure to store results
|
|
int numResults = 1;
|
|
if (_doMultiMaterial) numResults = resultMaterials.Length;
|
|
MB_AtlasesAndRects[] resultAtlasesAndRects = new MB_AtlasesAndRects[numResults];
|
|
for (int i = 0; i < resultAtlasesAndRects.Length; i++){
|
|
resultAtlasesAndRects[i] = new MB_AtlasesAndRects();
|
|
}
|
|
|
|
//Do the material combining.
|
|
for (int i = 0; i < resultAtlasesAndRects.Length; i++){
|
|
Material resMatToPass = null;
|
|
List<Material> sourceMats = null;
|
|
if (_doMultiMaterial) {
|
|
sourceMats = resultMaterials[i].sourceMaterials;
|
|
resMatToPass = resultMaterials[i].combinedMaterial;
|
|
} else {
|
|
resMatToPass = _resultMaterial;
|
|
}
|
|
LogManager.Log("Creating atlases for result material " + resMatToPass);
|
|
if(!combiner.CombineTexturesIntoAtlases(progressInfo, resultAtlasesAndRects[i], resMatToPass, objsToMesh, sourceMats, editorMethods)){
|
|
return null;
|
|
}
|
|
}
|
|
|
|
//Save the results
|
|
textureBakeResults.combinedMaterialInfo = resultAtlasesAndRects;
|
|
textureBakeResults.doMultiMaterial = _doMultiMaterial;
|
|
textureBakeResults.resultMaterial = _resultMaterial;
|
|
textureBakeResults.resultMaterials = resultMaterials;
|
|
textureBakeResults.fixOutOfBoundsUVs = combiner.fixOutOfBoundsUVs;
|
|
unpackMat2RectMap(textureBakeResults);
|
|
|
|
//set the texture bake resultAtlasesAndRects on the Mesh Baker component if it exists
|
|
MB3_MeshBakerCommon[] mb = GetComponentsInChildren<MB3_MeshBakerCommon>();
|
|
for (int i = 0; i < mb.Length; i++){
|
|
mb[i].textureBakeResults = textureBakeResults;
|
|
}
|
|
|
|
if (LOG_LEVEL >= MB2_LogLevel.info) LogManager.Log("Created Atlases");
|
|
return resultAtlasesAndRects;
|
|
}
|
|
|
|
void unpackMat2RectMap(MB2_TextureBakeResults tbr){
|
|
List<Material> ms = new List<Material>();
|
|
List<MB_MaterialAndUVRect> mss = new List<MB_MaterialAndUVRect>();
|
|
List<Rect> rs = new List<Rect>();
|
|
for (int i = 0; i < tbr.combinedMaterialInfo.Length; i++){
|
|
MB_AtlasesAndRects newMesh = tbr.combinedMaterialInfo[i];
|
|
List<MB_MaterialAndUVRect> map = newMesh.mat2rect_map;
|
|
for(int j = 0; j < map.Count; j++){
|
|
mss.Add(map[j]);
|
|
ms.Add(map[j].material);
|
|
rs.Add(map[j].atlasRect);
|
|
}
|
|
}
|
|
tbr.materialsAndUVRects = mss.ToArray();
|
|
tbr.materials = ms.ToArray();
|
|
tbr.prefabUVRects = rs.ToArray();
|
|
}
|
|
|
|
public static void ConfigureNewMaterialToMatchOld(Material newMat, Material original){
|
|
if (original == null){
|
|
LogManager.LogWarning("Original material is null, could not copy properties to " + newMat + ". Setting shader to " + newMat.shader);
|
|
return;
|
|
}
|
|
newMat.shader = original.shader;
|
|
newMat.CopyPropertiesFromMaterial(original);
|
|
ShaderTextureProperty[] texPropertyNames = MB3_TextureCombiner.shaderTexPropertyNames;
|
|
for (int j = 0; j < texPropertyNames.Length; j++){
|
|
Vector2 scale = Vector2.one;
|
|
Vector2 offset = Vector2.zero;
|
|
if (newMat.HasProperty(texPropertyNames[j].name)){
|
|
newMat.SetTextureOffset(texPropertyNames[j].name,offset);
|
|
newMat.SetTextureScale(texPropertyNames[j].name,scale);
|
|
}
|
|
}
|
|
}
|
|
|
|
string PrintSet(HashSet<Material> s){
|
|
StringBuilder sb = new StringBuilder();
|
|
foreach(Material m in s){
|
|
sb.Append( m + ",");
|
|
}
|
|
return sb.ToString();
|
|
}
|
|
|
|
bool _ValidateResultMaterials(){
|
|
HashSet<Material> allMatsOnObjs = new HashSet<Material>();
|
|
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) allMatsOnObjs.Add(ms[j]);
|
|
}
|
|
}
|
|
}
|
|
HashSet<Material> allMatsInMapping = new HashSet<Material>();
|
|
for (int i = 0; i < resultMaterials.Length; i++){
|
|
MB_MultiMaterial mm = resultMaterials[i];
|
|
if (mm.combinedMaterial == null){
|
|
LogManager.LogError("Combined Material is null please create and assign a result material.");
|
|
return false;
|
|
}
|
|
Shader targShader = mm.combinedMaterial.shader;
|
|
for (int j = 0; j < mm.sourceMaterials.Count; j++){
|
|
if (mm.sourceMaterials[j] == null){
|
|
LogManager.LogError("There are null entries in the list of Source Materials");
|
|
return false;
|
|
}
|
|
if (targShader != mm.sourceMaterials[j].shader){
|
|
LogManager.LogWarning("Source material " + mm.sourceMaterials[j] + " does not use shader " + targShader + " it may not have the required textures. If not empty textures will be generated.");
|
|
}
|
|
if (allMatsInMapping.Contains(mm.sourceMaterials[j])){
|
|
LogManager.LogError("A Material " + mm.sourceMaterials[j] + " appears more than once in the list of source materials in the source material to combined mapping. Each source material must be unique.");
|
|
return false;
|
|
}
|
|
allMatsInMapping.Add(mm.sourceMaterials[j]);
|
|
}
|
|
}
|
|
|
|
if (allMatsOnObjs.IsProperSubsetOf(allMatsInMapping)){
|
|
allMatsInMapping.ExceptWith(allMatsOnObjs);
|
|
LogManager.LogWarning("There are materials in the mapping that are not used on your source objects: " + PrintSet(allMatsInMapping));
|
|
}
|
|
if (allMatsInMapping.IsProperSubsetOf(allMatsOnObjs)){
|
|
allMatsOnObjs.ExceptWith(allMatsInMapping);
|
|
LogManager.LogError("There are materials on the objects to combine that are not in the mapping: " + PrintSet(allMatsOnObjs));
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|