public override IEnumerator CreateAtlases(ProgressUpdateDelegate progressInfo,
MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner,
AtlasPackingResult packedAtlasRects,
Texture2D[] atlases, MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Debug.Assert(!data.OnlyOneTextureInAtlasReuseTextures());
Rect[] uvRects = packedAtlasRects.rects;
long estArea = 0;
int atlasSizeX = 1;
int atlasSizeY = 1;
uvRects = null;
for (int propIdx = 0; propIdx < data.numAtlases; propIdx++)
{
//-----------------------
ShaderTextureProperty prop = data.texPropertyNames[propIdx];
Texture2D atlas = null;
if (!MB3_TextureCombinerPipeline._ShouldWeCreateAtlasForThisProperty(propIdx, data._considerNonTextureProperties, data.allTexturesAreNullAndSameColor))
{
atlas = null;
}
else
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.LogWarning("Beginning loop " + propIdx + " num temporary textures " + combiner._getNumTemporaryTextures());
}
MB3_TextureCombinerPackerRoot.CreateTemporaryTexturesForAtlas(data.distinctMaterialTextures, combiner, propIdx, data);
Texture2D[] texToPack = new Texture2D[data.distinctMaterialTextures.Count];
for (int texSetIdx = 0; texSetIdx < data.distinctMaterialTextures.Count; texSetIdx++)
{
MB_TexSet txs = data.distinctMaterialTextures[texSetIdx];
int tWidth = txs.idealWidth;
int tHeight = txs.idealHeight;
Texture2D tx = txs.ts[propIdx].GetTexture2D();
if (progressInfo != null)
{
progressInfo("Adjusting for scale and offset " + tx, .01f);
}
if (textureEditorMethods != null)
{
textureEditorMethods.SetReadWriteFlag(tx, true, true);
}
tx = GetAdjustedForScaleAndOffset2(prop.name, txs.ts[propIdx], txs.obUVoffset, txs.obUVscale, data, combiner, LOG_LEVEL);
//create a resized copy if necessary
if (tx.width != tWidth || tx.height != tHeight)
{
if (progressInfo != null)
{
progressInfo("Resizing texture '" + tx + "'", .01f);
}
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.LogWarning("Copying and resizing texture " + prop.name + " from " + tx.width + "x" + tx.height + " to " + tWidth + "x" + tHeight);
}
tx = combiner._resizeTexture(prop.name, (Texture2D)tx, tWidth, tHeight);
}
estArea += tx.width * tx.height;
if (data._considerNonTextureProperties)
{
//combine the tintColor with the texture
tx = combiner._createTextureCopy(prop.name, tx);
data.nonTexturePropertyBlender.TintTextureWithTextureCombiner(tx, data.distinctMaterialTextures[texSetIdx], prop);
}
texToPack[texSetIdx] = tx;
}
if (textureEditorMethods != null)
{
textureEditorMethods.CheckBuildSettings(estArea);
}
if (Math.Sqrt(estArea) > 3500f)
{
if (LOG_LEVEL >= MB2_LogLevel.warn)
{
Debug.LogWarning("The maximum possible atlas size is 4096. Textures may be shrunk");
}
}
atlas = new Texture2D(1, 1, TextureFormat.ARGB32, true);
if (progressInfo != null)
{
progressInfo("Packing texture atlas " + prop.name, .25f);
}
if (propIdx == 0)
{
if (progressInfo != null)
{
progressInfo("Estimated min size of atlases: " + Math.Sqrt(estArea).ToString("F0"), .1f);
}
if (LOG_LEVEL >= MB2_LogLevel.info)
{
Debug.Log("Estimated atlas minimum size:" + Math.Sqrt(estArea).ToString("F0"));
}
int maxAtlasSize = 4096;
uvRects = atlas.PackTextures(texToPack, data._atlasPadding, maxAtlasSize, false);
if (LOG_LEVEL >= MB2_LogLevel.info)
{
Debug.Log("After pack textures atlas size " + atlas.width + " " + atlas.height);
}
atlasSizeX = atlas.width;
atlasSizeY = atlas.height;
atlas.Apply();
}
else
{
if (progressInfo != null)
{
progressInfo("Copying Textures Into: " + prop.name, .1f);
}
atlas = _copyTexturesIntoAtlas(texToPack, data._atlasPadding, uvRects, atlasSizeX, atlasSizeY, combiner);
}
}
atlases[propIdx] = atlas;
//----------------------
if (data._saveAtlasesAsAssets && textureEditorMethods != null)
{
textureEditorMethods.SaveAtlasToAssetDatabase(atlases[propIdx], prop, propIdx, data.resultMaterial);
}
data.resultMaterial.SetTextureOffset(prop.name, Vector2.zero);
data.resultMaterial.SetTextureScale(prop.name, Vector2.one);
combiner._destroyTemporaryTextures(prop.name);
GC.Collect();
}
packedAtlasRects.rects = uvRects;
yield break;
}
public static IEnumerator _CreateAtlasesCoroutineSingleResultMaterial(int resMatIdx,
MB_TextureArrayResultMaterial bakedMatsAndSlicesResMat,
MB_MultiMaterialTexArray resMatConfig,
List <GameObject> objsToMesh,
MB3_TextureCombiner combiner,
MB_TextureArrayFormatSet[] textureArrayOutputFormats,
MB_MultiMaterialTexArray[] resultMaterialsTexArray,
List <ShaderTextureProperty> customShaderProperties,
ProgressUpdateDelegate progressInfo,
MB3_TextureCombiner.CreateAtlasesCoroutineResult coroutineResult,
bool saveAtlasesAsAssets = false,
MB2_EditorMethodsInterface editorMethods = null,
float maxTimePerFrame = .01f)
{
MB2_LogLevel LOG_LEVEL = combiner.LOG_LEVEL;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Baking atlases for result material " + resMatIdx + " num slices:" + resMatConfig.slices.Count);
}
// Each result material can be one set of slices per textureProperty. Each slice can be an atlas.
// Create atlases for each slice.
List <MB3_TextureCombiner.TemporaryTexture> generatedTemporaryAtlases = new List <MB3_TextureCombiner.TemporaryTexture>();
{
combiner.saveAtlasesAsAssets = false; // Don't want generated atlas slices to be assets
List <MB_TexArraySlice> slicesConfig = resMatConfig.slices;
for (int sliceIdx = 0; sliceIdx < slicesConfig.Count; sliceIdx++)
{
Material resMatToPass = null;
List <MB_TexArraySliceRendererMatPair> srcMatAndObjPairs = slicesConfig[sliceIdx].sourceMaterials;
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log(" Baking atlases for result material:" + resMatIdx + " slice:" + sliceIdx);
}
resMatToPass = resMatConfig.combinedMaterial;
combiner.fixOutOfBoundsUVs = slicesConfig[sliceIdx].considerMeshUVs;
MB3_TextureCombiner.CombineTexturesIntoAtlasesCoroutineResult coroutineResult2 = new MB3_TextureCombiner.CombineTexturesIntoAtlasesCoroutineResult();
MB_AtlasesAndRects sliceAtlasesAndRectOutput = bakedMatsAndSlicesResMat.slices[sliceIdx];
List <Material> usedMats = new List <Material>();
slicesConfig[sliceIdx].GetAllUsedMaterials(usedMats);
yield return(combiner.CombineTexturesIntoAtlasesCoroutine(progressInfo, sliceAtlasesAndRectOutput, resMatToPass, slicesConfig[sliceIdx].GetAllUsedRenderers(objsToMesh), usedMats, editorMethods, coroutineResult2, maxTimePerFrame,
onlyPackRects: false, splitAtlasWhenPackingIfTooBig: false));
coroutineResult.success = coroutineResult2.success;
if (!coroutineResult.success)
{
coroutineResult.isFinished = true;
yield break;
}
// Track which slices are new generated texture instances. Atlases could be original texture assets (one tex per atlas) or temporary texture instances in memory that will need to be destroyed.
{
for (int texPropIdx = 0; texPropIdx < sliceAtlasesAndRectOutput.atlases.Length; texPropIdx++)
{
Texture2D atlas = sliceAtlasesAndRectOutput.atlases[texPropIdx];
if (atlas != null)
{
bool atlasWasASourceTexture = false;
for (int srcMatIdx = 0; srcMatIdx < srcMatAndObjPairs.Count; srcMatIdx++)
{
Material srcMat = srcMatAndObjPairs[srcMatIdx].sourceMaterial;
if (srcMat.HasProperty(sliceAtlasesAndRectOutput.texPropertyNames[texPropIdx]) &&
srcMat.GetTexture(sliceAtlasesAndRectOutput.texPropertyNames[texPropIdx]) == atlas)
{
atlasWasASourceTexture = true;
break;
}
}
if (!atlasWasASourceTexture)
{
generatedTemporaryAtlases.Add(new MB3_TextureCombiner.TemporaryTexture(sliceAtlasesAndRectOutput.texPropertyNames[texPropIdx], atlas));
}
}
}
} // end visit slices
Debug.Assert(combiner._getNumTemporaryTextures() == 0, "Combiner should have no temporary textures.");
}
combiner.saveAtlasesAsAssets = saveAtlasesAsAssets; // Restore original setting.
}
// Generated atlas textures are temporary for texture arrays. They exist only in memory. Need to be cleaned up after we create slices.
for (int i = 0; i < generatedTemporaryAtlases.Count; i++)
{
combiner.AddTemporaryTexture(generatedTemporaryAtlases[i]);
}
List <ShaderTextureProperty> texPropertyNames = new List <ShaderTextureProperty>();
MB3_TextureCombinerPipeline._CollectPropertyNames(texPropertyNames, customShaderProperties, resMatConfig.combinedMaterial, LOG_LEVEL);
// The slices are built from different source-material-lists. Each slice can have different sets of texture properties missing (nulls).
// Build a master list of texture properties.
bool[] hasTexForProperty = MB_TextureArrays.DetermineWhichPropertiesHaveTextures(bakedMatsAndSlicesResMat.slices);
List <Texture2D> temporaryTextureAssets = new List <Texture2D>();
try
{
MB_MultiMaterialTexArray resMaterial = resMatConfig;
Dictionary <string, MB_TexArrayForProperty> resTexArraysByProperty = new Dictionary <string, MB_TexArrayForProperty>();
{
// Initialize so I don't need to check if properties exist later.
for (int propIdx = 0; propIdx < texPropertyNames.Count; propIdx++)
{
if (hasTexForProperty[propIdx])
{
resTexArraysByProperty[texPropertyNames[propIdx].name] =
new MB_TexArrayForProperty(texPropertyNames[propIdx].name, new MB_TextureArrayReference[textureArrayOutputFormats.Length]);
}
}
}
MB3_TextureCombinerNonTextureProperties textureBlender = null;
textureBlender = new MB3_TextureCombinerNonTextureProperties(LOG_LEVEL, combiner.considerNonTextureProperties);
textureBlender.LoadTextureBlendersIfNeeded(resMatConfig.combinedMaterial);
textureBlender.AdjustNonTextureProperties(resMatConfig.combinedMaterial, texPropertyNames, editorMethods);
// Vist each TextureFormatSet
for (int texFormatSetIdx = 0; texFormatSetIdx < textureArrayOutputFormats.Length; texFormatSetIdx++)
{
MB_TextureArrayFormatSet textureArrayFormatSet = textureArrayOutputFormats[texFormatSetIdx];
editorMethods.Clear();
MB_TextureArrays.TexturePropertyData texPropertyData = new MB_TextureArrays.TexturePropertyData();
MB_TextureArrays.FindBestSizeAndMipCountAndFormatForTextureArrays(texPropertyNames, combiner.maxAtlasSize, textureArrayFormatSet, bakedMatsAndSlicesResMat.slices, texPropertyData);
// Create textures we might need to create if they don't exist.
{
for (int propIdx = 0; propIdx < hasTexForProperty.Length; propIdx++)
{
if (hasTexForProperty[propIdx])
{
TextureFormat format = texPropertyData.formats[propIdx];
int numSlices = bakedMatsAndSlicesResMat.slices.Length;
int targetWidth = (int)texPropertyData.sizes[propIdx].x;
int targetHeight = (int)texPropertyData.sizes[propIdx].y;
for (int sliceIdx = 0; sliceIdx < numSlices; sliceIdx++)
{
if (bakedMatsAndSlicesResMat.slices[sliceIdx].atlases[propIdx] == null)
{
// Can only setSolidColor on truecolor textures. First create a texture in trucolor format
Texture2D sliceTex = new Texture2D(targetWidth, targetHeight, TextureFormat.ARGB32, texPropertyData.doMips[propIdx]);
Color col = textureBlender.GetColorForTemporaryTexture(resMatConfig.slices[sliceIdx].sourceMaterials[0].sourceMaterial, texPropertyNames[propIdx]);
MB_Utility.setSolidColor(sliceTex, col);
// Now create a copy of this texture in target format.
bakedMatsAndSlicesResMat.slices[sliceIdx].atlases[propIdx] = editorMethods.CreateTemporaryAssetCopy(texPropertyNames[propIdx], sliceTex, targetWidth, targetHeight, format, LOG_LEVEL);
temporaryTextureAssets.Add(bakedMatsAndSlicesResMat.slices[sliceIdx].atlases[propIdx]);
MB_Utility.Destroy(sliceTex);
}
}
}
}
}
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Converting source textures to readable formats.");
}
if (MB_TextureArrays.ConvertTexturesToReadableFormat(texPropertyData, bakedMatsAndSlicesResMat.slices, hasTexForProperty, texPropertyNames, combiner, LOG_LEVEL, temporaryTextureAssets, editorMethods))
{
// We now have a set of slices (one per textureProperty). Build these into Texture2DArray's.
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Creating texture arrays");
}
if (LOG_LEVEL >= MB2_LogLevel.info)
{
Debug.Log("THERE MAY BE ERRORS IN THE CONSOLE ABOUT 'Rebuilding mipmaps ... not supported'. THESE ARE PROBABLY FALSE POSITIVES AND CAN BE IGNORED.");
}
Texture2DArray[] textureArrays = MB_TextureArrays.CreateTextureArraysForResultMaterial(texPropertyData, texPropertyNames, bakedMatsAndSlicesResMat.slices, hasTexForProperty, combiner, LOG_LEVEL);
// Now have texture arrays for a result material, for all props. Save it.
for (int propIdx = 0; propIdx < textureArrays.Length; propIdx++)
{
if (hasTexForProperty[propIdx])
{
MB_TextureArrayReference texRef = new MB_TextureArrayReference(textureArrayFormatSet.name, textureArrays[propIdx]);
resTexArraysByProperty[texPropertyNames[propIdx].name].formats[texFormatSetIdx] = texRef;
if (saveAtlasesAsAssets)
{
editorMethods.SaveTextureArrayToAssetDatabase(textureArrays[propIdx],
textureArrayFormatSet.GetFormatForProperty(texPropertyNames[propIdx].name),
bakedMatsAndSlicesResMat.slices[0].texPropertyNames[propIdx],
propIdx, resMaterial.combinedMaterial);
}
}
}
}
} // end vist format set
resMaterial.textureProperties = new List <MB_TexArrayForProperty>();
foreach (MB_TexArrayForProperty val in resTexArraysByProperty.Values)
{
resMaterial.textureProperties.Add(val);
}
}
catch (Exception e)
{
Debug.LogError(e.Message + "\n" + e.StackTrace.ToString());
coroutineResult.isFinished = true;
coroutineResult.success = false;
}
finally
{
editorMethods.RestoreReadFlagsAndFormats(progressInfo);
combiner._destroyAllTemporaryTextures();
for (int i = 0; i < temporaryTextureAssets.Count; i++)
{
editorMethods.DestroyAsset(temporaryTextureAssets[i]);
}
temporaryTextureAssets.Clear();
}
}
