public void CreateColoredTexToReplaceNull(string propName, int propIdx, bool considerMeshUVs, MB3_TextureCombiner combiner, Color col)
{
MeshBakerMaterialTexture matTex = ts[propIdx];
matTex.t = combiner._createTemporaryTexture(propName, 16, 16, TextureFormat.ARGB32, true);
MB_Utility.setSolidColor(matTex.GetTexture2D(), col);
}
public virtual IEnumerator ConvertTexturesToReadableFormats(ProgressUpdateDelegate progressInfo,
MB3_TextureCombiner.CombineTexturesIntoAtlasesCoroutineResult result,
MB3_TextureCombinerPipeline.TexturePipelineData data,
MB3_TextureCombiner combiner,
MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Debug.Assert(!data.OnlyOneTextureInAtlasReuseTextures());
//MakeProceduralTexturesReadable(progressInfo, result, data, combiner, textureEditorMethods, LOG_LEVEL);
for (int i = 0; i < data.distinctMaterialTextures.Count; i++)
{
for (int j = 0; j < data.texPropertyNames.Count; j++)
{
MeshBakerMaterialTexture ts = data.distinctMaterialTextures[i].ts[j];
if (!ts.isNull)
{
if (textureEditorMethods != null)
{
Texture tx = ts.GetTexture2D();
TextureFormat format = TextureFormat.ARGB32;
if (progressInfo != null)
{
progressInfo(String.Format("Convert texture {0} to readable format ", tx), .5f);
}
textureEditorMethods.AddTextureFormat((Texture2D)tx, format, data.texPropertyNames[j].isNormalMap);
}
}
}
}
yield break;
}
public 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());
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Only one image per atlas. Will re-use original texture");
}
for (int i = 0; i < data.numAtlases; i++)
{
MeshBakerMaterialTexture dmt = data.distinctMaterialTextures[0].ts[i];
atlases[i] = dmt.GetTexture2D();
if (data.resultType == MB2_TextureBakeResults.ResultType.atlas)
{
data.resultMaterial.SetTexture(data.texPropertyNames[i].name, atlases[i]);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, Vector2.one);
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, Vector2.zero);
}
}
yield break;
}
public AtlasPackingResult[] CalculateAtlasRectangles(MB3_TextureCombinerPipeline.TexturePipelineData data, bool doMultiAtlas, MB2_LogLevel LOG_LEVEL)
{
Debug.Assert(data.OnlyOneTextureInAtlasReuseTextures());
if (LOG_LEVEL >= MB2_LogLevel.debug) Debug.Log("Only one image per atlas. Will re-use original texture");
AtlasPackingResult[] packerRects = new AtlasPackingResult[1];
AtlasPadding[] paddings = new AtlasPadding[] { new AtlasPadding(data._atlasPadding) };
packerRects[0] = new AtlasPackingResult(paddings);
packerRects[0].rects = new Rect[1];
packerRects[0].srcImgIdxs = new int[] { 0 };
packerRects[0].rects[0] = new Rect(0f, 0f, 1f, 1f);
MeshBakerMaterialTexture dmt = null;
if (data.distinctMaterialTextures[0].ts.Length > 0)
{
dmt = data.distinctMaterialTextures[0].ts[0];
}
if (dmt == null || dmt.isNull)
{
packerRects[0].atlasX = 16;
packerRects[0].atlasY = 16;
packerRects[0].usedW = 16;
packerRects[0].usedH = 16;
}
else
{
packerRects[0].atlasX = dmt.width;
packerRects[0].atlasY = dmt.height;
packerRects[0].usedW = dmt.width;
packerRects[0].usedH = dmt.height;
}
return packerRects;
}
public bool AreTexturesEqual(MeshBakerMaterialTexture b)
{
if (_t == b._t /*&& _procT == b._procT*/)
{
return(true);
}
return(false);
}
// used by Unity texture packer to handle tiled textures.
// may create a new texture that has the correct tiling to handle fix out of bounds UVs
internal static Texture2D GetAdjustedForScaleAndOffset2(string propertyName, MeshBakerMaterialTexture source, Vector2 obUVoffset, Vector2 obUVscale, MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner, MB2_LogLevel LOG_LEVEL)
{
Texture2D sourceTex = source.GetTexture2D();
if (source.matTilingRect.x == 0f && source.matTilingRect.y == 0f && source.matTilingRect.width == 1f && source.matTilingRect.height == 1f)
{
if (data._fixOutOfBoundsUVs)
{
if (obUVoffset.x == 0f && obUVoffset.y == 0f && obUVscale.x == 1f && obUVscale.y == 1f)
{
return(sourceTex); //no adjustment necessary
}
}
else
{
return(sourceTex); //no adjustment necessary
}
}
Vector2 dim = MB3_TextureCombinerPipeline.GetAdjustedForScaleAndOffset2Dimensions(source, obUVoffset, obUVscale, data, LOG_LEVEL);
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.LogWarning("GetAdjustedForScaleAndOffset2: " + sourceTex + " " + obUVoffset + " " + obUVscale);
}
float newWidth = dim.x;
float newHeight = dim.y;
float scx = (float)source.matTilingRect.width;
float scy = (float)source.matTilingRect.height;
float ox = (float)source.matTilingRect.x;
float oy = (float)source.matTilingRect.y;
if (data._fixOutOfBoundsUVs)
{
scx *= obUVscale.x;
scy *= obUVscale.y;
ox = (float)(source.matTilingRect.x * obUVscale.x + obUVoffset.x);
oy = (float)(source.matTilingRect.y * obUVscale.y + obUVoffset.y);
}
Texture2D newTex = combiner._createTemporaryTexture(propertyName, (int)newWidth, (int)newHeight, TextureFormat.ARGB32, true);
for (int i = 0; i < newTex.width; i++)
{
for (int j = 0; j < newTex.height; j++)
{
float u = i / newWidth * scx + ox;
float v = j / newHeight * scy + oy;
newTex.SetPixel(i, j, sourceTex.GetPixelBilinear(u, v));
}
}
newTex.Apply();
return(newTex);
}
public Vector2 GetMaxRawTextureHeightWidth()
{
Vector2 max = new Vector2(0, 0);
for (int propIdx = 0; propIdx < ts.Length; propIdx++)
{
MeshBakerMaterialTexture tx = ts[propIdx];
if (!tx.isNull)
{
max.x = Mathf.Max(max.x, tx.width);
max.y = Mathf.Max(max.y, tx.height);
}
}
return max;
}
internal static void CreateTemporaryTexturesForAtlas(List <MB_TexSet> distinctMaterialTextures, MB3_TextureCombiner combiner, int propIdx, MB3_TextureCombinerPipeline.TexturePipelineData data)
{
for (int texSetIdx = 0; texSetIdx < data.distinctMaterialTextures.Count; texSetIdx++)
{
MB_TexSet txs = data.distinctMaterialTextures[texSetIdx];
MeshBakerMaterialTexture matTex = txs.ts[propIdx];
if (matTex.isNull)
{
//create a small 16 x 16 texture to use in the atlas
Color col = data.nonTexturePropertyBlender.GetColorForTemporaryTexture(txs.matsAndGOs.mats[0].mat, data.texPropertyNames[propIdx]);
txs.CreateColoredTexToReplaceNull(data.texPropertyNames[propIdx].name, propIdx, data._fixOutOfBoundsUVs, combiner, col);
}
}
}
public IEnumerator CreateAtlases(ProgressUpdateDelegate progressInfo,
MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner,
AtlasPackingResult packedAtlasRects,
Texture2D[] atlases, MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Rect[] uvRects = packedAtlasRects.rects;
if (uvRects.Length == 1)
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Only one image per atlas. Will re-use original texture");
}
for (int i = 0; i < data.numAtlases; i++)
{
MeshBakerMaterialTexture dmt = data.distinctMaterialTextures[0].ts[i];
atlases[i] = dmt.GetTexture2D();
data.resultMaterial.SetTexture(data.texPropertyNames[i].name, atlases[i]);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, dmt.matTilingRect.size);
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, dmt.matTilingRect.min);
}
}
else
{
int atlasSizeX = packedAtlasRects.atlasX;
int atlasSizeY = packedAtlasRects.atlasY;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Generated atlas will be " + atlasSizeX + "x" + atlasSizeY);
}
for (int propIdx = 0; propIdx < data.numAtlases; propIdx++)
{
Texture2D atlas = null;
if (!MB3_TextureCombinerPipeline._ShouldWeCreateAtlasForThisProperty(propIdx, data._considerNonTextureProperties, data.allTexturesAreNullAndSameColor))
{
atlas = null;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("=== Not creating atlas for " + data.texPropertyNames[propIdx].name + " because textures are null and default value parameters are the same.");
}
}
else
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("=== Creating atlas for " + data.texPropertyNames[propIdx].name);
}
GC.Collect();
//use a jagged array because it is much more efficient in memory
Color[][] atlasPixels = new Color[atlasSizeY][];
for (int j = 0; j < atlasPixels.Length; j++)
{
atlasPixels[j] = new Color[atlasSizeX];
}
bool isNormalMap = false;
if (data.texPropertyNames[propIdx].isNormalMap)
{
isNormalMap = true;
}
for (int texSetIdx = 0; texSetIdx < data.distinctMaterialTextures.Count; texSetIdx++)
{
string s = "Creating Atlas '" + data.texPropertyNames[propIdx].name + "' texture " + data.distinctMaterialTextures[texSetIdx];
if (progressInfo != null)
{
progressInfo(s, .01f);
}
MB_TexSet texSet = data.distinctMaterialTextures[texSetIdx];
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log(string.Format("Adding texture {0} to atlas {1}", texSet.ts[propIdx].GetTexture2D() == null ? "null" : texSet.ts[propIdx].GetTexName(), data.texPropertyNames[propIdx]));
}
Rect r = uvRects[texSetIdx];
Texture2D t = texSet.ts[propIdx].GetTexture2D();
int x = Mathf.RoundToInt(r.x * atlasSizeX);
int y = Mathf.RoundToInt(r.y * atlasSizeY);
int ww = Mathf.RoundToInt(r.width * atlasSizeX);
int hh = Mathf.RoundToInt(r.height * atlasSizeY);
if (ww == 0 || hh == 0)
{
Debug.LogError("Image in atlas has no height or width " + r);
}
if (progressInfo != null)
{
progressInfo(s + " set ReadWrite flag", .01f);
}
if (textureEditorMethods != null)
{
textureEditorMethods.SetReadWriteFlag(t, true, true);
}
if (progressInfo != null)
{
progressInfo(s + "Copying to atlas: '" + texSet.ts[propIdx].GetTexName() + "'", .02f);
}
DRect samplingRect = texSet.ts[propIdx].encapsulatingSamplingRect;
yield return(CopyScaledAndTiledToAtlas(texSet.ts[propIdx], texSet, data.texPropertyNames[propIdx], samplingRect, x, y, ww, hh, packedAtlasRects.padding[texSetIdx], atlasPixels, isNormalMap, data, combiner, progressInfo, LOG_LEVEL));
// Debug.Log("after copyScaledAndTiledAtlas");
}
yield return(data.numAtlases);
if (progressInfo != null)
{
progressInfo("Applying changes to atlas: '" + data.texPropertyNames[propIdx].name + "'", .03f);
}
atlas = new Texture2D(atlasSizeX, atlasSizeY, TextureFormat.ARGB32, true);
for (int j = 0; j < atlasPixels.Length; j++)
{
atlas.SetPixels(0, j, atlasSizeX, 1, atlasPixels[j]);
}
atlas.Apply();
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Saving atlas " + data.texPropertyNames[propIdx].name + " w=" + atlas.width + " h=" + atlas.height);
}
}
atlases[propIdx] = atlas;
if (progressInfo != null)
{
progressInfo("Saving atlas: '" + data.texPropertyNames[propIdx].name + "'", .04f);
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
if (data._saveAtlasesAsAssets && textureEditorMethods != null)
{
textureEditorMethods.SaveAtlasToAssetDatabase(atlases[propIdx], data.texPropertyNames[propIdx], propIdx, data.resultMaterial);
}
else
{
data.resultMaterial.SetTexture(data.texPropertyNames[propIdx].name, atlases[propIdx]);
}
data.resultMaterial.SetTextureOffset(data.texPropertyNames[propIdx].name, Vector2.zero);
data.resultMaterial.SetTextureScale(data.texPropertyNames[propIdx].name, Vector2.one);
combiner._destroyTemporaryTextures(); // need to save atlases before doing this
}
}
//data.rectsInAtlas = uvRects;
// Debug.Log("finished!");
yield break;
}
internal static IEnumerator CopyScaledAndTiledToAtlas(MeshBakerMaterialTexture source, MB_TexSet sourceMaterial,
ShaderTextureProperty shaderPropertyName, DRect srcSamplingRect, int targX, int targY, int targW, int targH,
AtlasPadding padding,
Color[][] atlasPixels, bool isNormalMap,
MB3_TextureCombinerPipeline.TexturePipelineData data,
MB3_TextureCombiner combiner,
ProgressUpdateDelegate progressInfo = null,
MB2_LogLevel LOG_LEVEL = MB2_LogLevel.info)
{
//HasFinished = false;
Texture2D t = source.GetTexture2D();
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("CopyScaledAndTiledToAtlas: " + t + " inAtlasX=" + targX + " inAtlasY=" + targY + " inAtlasW=" + targW + " inAtlasH=" + targH);
}
float newWidth = targW;
float newHeight = targH;
float scx = (float)srcSamplingRect.width;
float scy = (float)srcSamplingRect.height;
float ox = (float)srcSamplingRect.x;
float oy = (float)srcSamplingRect.y;
int w = (int)newWidth;
int h = (int)newHeight;
if (t == null)
{
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log("No source texture creating a 16x16 texture.");
}
t = combiner._createTemporaryTexture(16, 16, TextureFormat.ARGB32, true);
scx = 1;
scy = 1;
if (data._considerNonTextureProperties && data.nonTexturePropertyBlender != null)
{
Color col = data.nonTexturePropertyBlender.GetColorIfNoTexture(sourceMaterial.matsAndGOs.mats[0].mat, shaderPropertyName);
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log("Setting texture to solid color " + col);
}
MB_Utility.setSolidColor(t, col);
}
else
{
Color col = MB3_TextureCombinerNonTextureProperties.GetColorIfNoTexture(shaderPropertyName);
MB_Utility.setSolidColor(t, col);
}
}
if (data._considerNonTextureProperties && data.nonTexturePropertyBlender != null)
{
t = combiner._createTextureCopy(t);
t = data.nonTexturePropertyBlender.TintTextureWithTextureCombiner(t, sourceMaterial, shaderPropertyName);
}
for (int i = 0; i < w; i++)
{
if (progressInfo != null && w > 0)
{
progressInfo("CopyScaledAndTiledToAtlas " + (((float)i / (float)w) * 100f).ToString("F0"), .2f);
}
for (int j = 0; j < h; j++)
{
float u = i / newWidth * scx + ox;
float v = j / newHeight * scy + oy;
atlasPixels[targY + j][targX + i] = t.GetPixelBilinear(u, v);
}
}
//bleed the border colors into the padding
for (int i = 0; i < w; i++)
{
for (int j = 1; j <= padding.topBottom; j++)
{
//top margin
atlasPixels[(targY - j)][targX + i] = atlasPixels[(targY)][targX + i];
//bottom margin
atlasPixels[(targY + h - 1 + j)][targX + i] = atlasPixels[(targY + h - 1)][targX + i];
}
}
for (int j = 0; j < h; j++)
{
for (int i = 1; i <= padding.leftRight; i++)
{
//left margin
atlasPixels[(targY + j)][targX - i] = atlasPixels[(targY + j)][targX];
//right margin
atlasPixels[(targY + j)][targX + w + i - 1] = atlasPixels[(targY + j)][targX + w - 1];
}
}
//corners
for (int i = 1; i <= padding.leftRight; i++)
{
for (int j = 1; j <= padding.topBottom; j++)
{
atlasPixels[(targY - j)][targX - i] = atlasPixels[targY][targX];
atlasPixels[(targY + h - 1 + j)][targX - i] = atlasPixels[(targY + h - 1)][targX];
atlasPixels[(targY + h - 1 + j)][targX + w + i - 1] = atlasPixels[(targY + h - 1)][targX + w - 1];
atlasPixels[(targY - j)][targX + w + i - 1] = atlasPixels[targY][targX + w - 1];
yield return(null);
}
yield return(null);
}
// Debug.Log("copyandscaledatlas finished too!");
//HasFinished = true;
yield break;
}
public IEnumerator CreateAtlases(ProgressUpdateDelegate progressInfo,
MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner,
AtlasPackingResult packedAtlasRects,
Texture2D[] atlases, MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Rect[] uvRects = packedAtlasRects.rects;
if (data.distinctMaterialTextures.Count == 1 && data._fixOutOfBoundsUVs == false)
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Only one image per atlas. Will re-use original texture");
}
uvRects = new Rect[1];
uvRects[0] = new Rect(0f, 0f, 1f, 1f);
for (int i = 0; i < data.numAtlases; i++)
{
MeshBakerMaterialTexture dmt = data.distinctMaterialTextures[0].ts[i];
atlases[i] = dmt.GetTexture2D();
data.resultMaterial.SetTexture(data.texPropertyNames[i].name, atlases[i]);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, dmt.matTilingRect.size);
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, dmt.matTilingRect.min);
}
}
else
{
long estArea = 0;
int atlasSizeX = 1;
int atlasSizeY = 1;
uvRects = null;
for (int i = 0; i < data.numAtlases; i++)
{ //i is an atlas "MainTex", "BumpMap" etc...
//-----------------------
Texture2D atlas = null;
if (!MB3_TextureCombinerPipeline._ShouldWeCreateAtlasForThisProperty(i, data._considerNonTextureProperties, data.allTexturesAreNullAndSameColor))
{
atlas = null;
}
else
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.LogWarning("Beginning loop " + i + " num temporary textures " + combiner._temporaryTextures.Count);
}
for (int j = 0; j < data.distinctMaterialTextures.Count; j++)
{ //j is a distinct set of textures one for each of "MainTex", "BumpMap" etc...
MB_TexSet txs = data.distinctMaterialTextures[j];
int tWidth = txs.idealWidth;
int tHeight = txs.idealHeight;
Texture2D tx = txs.ts[i].GetTexture2D();
if (tx == null)
{
tx = txs.ts[i].t = combiner._createTemporaryTexture(tWidth, tHeight, TextureFormat.ARGB32, true);
if (data._considerNonTextureProperties && data.nonTexturePropertyBlender != null)
{
Color col = data.nonTexturePropertyBlender.GetColorIfNoTexture(txs.matsAndGOs.mats[0].mat, data.texPropertyNames[i]);
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log("Setting texture to solid color " + col);
}
MB_Utility.setSolidColor(tx, col);
}
else
{
Color col = MB3_TextureCombinerNonTextureProperties.GetColorIfNoTexture(data.texPropertyNames[i]);
MB_Utility.setSolidColor(tx, col);
}
}
if (progressInfo != null)
{
progressInfo("Adjusting for scale and offset " + tx, .01f);
}
if (textureEditorMethods != null)
{
textureEditorMethods.SetReadWriteFlag(tx, true, true);
}
tx = GetAdjustedForScaleAndOffset2(txs.ts[i], 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 " + data.texPropertyNames[i].name + " from " + tx.width + "x" + tx.height + " to " + tWidth + "x" + tHeight);
}
tx = combiner._resizeTexture((Texture2D)tx, tWidth, tHeight);
}
txs.ts[i].t = tx;
}
Texture2D[] texToPack = new Texture2D[data.distinctMaterialTextures.Count];
for (int j = 0; j < data.distinctMaterialTextures.Count; j++)
{
Texture2D tx = data.distinctMaterialTextures[j].ts[i].GetTexture2D();
estArea += tx.width * tx.height;
if (data._considerNonTextureProperties)
{
//combine the tintColor with the texture
tx = combiner._createTextureCopy(tx);
data.nonTexturePropertyBlender.TintTextureWithTextureCombiner(tx, data.distinctMaterialTextures[j], data.texPropertyNames[i]);
}
texToPack[j] = 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 " + data.texPropertyNames[i].name, .25f);
}
if (i == 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"));
}
if (data.distinctMaterialTextures.Count == 1 && data._fixOutOfBoundsUVs == false)
{ //don't want to force power of 2 so tiling will still work
uvRects = new Rect[1] {
new Rect(0f, 0f, 1f, 1f)
};
atlas = _copyTexturesIntoAtlas(texToPack, data._atlasPadding, uvRects, texToPack[0].width, texToPack[0].height, combiner);
}
else
{
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: " + data.texPropertyNames[i].name, .1f);
}
atlas = _copyTexturesIntoAtlas(texToPack, data._atlasPadding, uvRects, atlasSizeX, atlasSizeY, combiner);
}
}
atlases[i] = atlas;
//----------------------
if (data._saveAtlasesAsAssets && textureEditorMethods != null)
{
textureEditorMethods.SaveAtlasToAssetDatabase(atlases[i], data.texPropertyNames[i], i, data.resultMaterial);
}
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, Vector2.zero);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, Vector2.one);
combiner._destroyTemporaryTextures(); // need to save atlases before doing this
GC.Collect();
}
}
packedAtlasRects.rects = uvRects;
yield break;
}
public bool AreTexturesEqual(MeshBakerMaterialTexture b)
{
if (_t == b._t /*&& _procT == b._procT*/) return true;
return false;
}
public IEnumerator CreateAtlases(ProgressUpdateDelegate progressInfo,
MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner,
AtlasPackingResult packedAtlasRects,
Texture2D[] atlases, MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Rect[] uvRects = packedAtlasRects.rects;
if (uvRects.Length == 1)
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Only one image per atlas. Will re-use original texture");
}
for (int i = 0; i < data.numAtlases; i++)
{
MeshBakerMaterialTexture dmt = data.distinctMaterialTextures[0].ts[i];
atlases[i] = dmt.GetTexture2D();
data.resultMaterial.SetTexture(data.texPropertyNames[i].name, atlases[i]);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, dmt.matTilingRect.size);
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, dmt.matTilingRect.min);
}
}
else
{
int atlasSizeX = packedAtlasRects.atlasX;
int atlasSizeY = packedAtlasRects.atlasY;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Generated atlas will be " + atlasSizeX + "x" + atlasSizeY);
}
//create a game object
GameObject renderAtlasesGO = null;
try
{
renderAtlasesGO = new GameObject("MBrenderAtlasesGO");
MB3_AtlasPackerRenderTexture atlasRenderTexture = renderAtlasesGO.AddComponent <MB3_AtlasPackerRenderTexture>();
renderAtlasesGO.AddComponent <Camera>();
if (data._considerNonTextureProperties)
{
if (LOG_LEVEL >= MB2_LogLevel.warn)
{
Debug.LogWarning("Blend Non-Texture Properties has limited functionality when used with Mesh Baker Texture Packer Fast.");
}
}
for (int i = 0; i < data.numAtlases; i++)
{
Texture2D atlas = null;
if (!MB3_TextureCombinerPipeline._ShouldWeCreateAtlasForThisProperty(i, data._considerNonTextureProperties, data.allTexturesAreNullAndSameColor))
{
atlas = null;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Not creating atlas for " + data.texPropertyNames[i].name + " because textures are null and default value parameters are the same.");
}
}
else
{
GC.Collect();
if (progressInfo != null)
{
progressInfo("Creating Atlas '" + data.texPropertyNames[i].name + "'", .01f);
}
// ===========
// configure it
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("About to render " + data.texPropertyNames[i].name + " isNormal=" + data.texPropertyNames[i].isNormalMap);
}
atlasRenderTexture.LOG_LEVEL = LOG_LEVEL;
atlasRenderTexture.width = atlasSizeX;
atlasRenderTexture.height = atlasSizeY;
atlasRenderTexture.padding = data._atlasPadding;
atlasRenderTexture.rects = uvRects;
atlasRenderTexture.textureSets = data.distinctMaterialTextures;
atlasRenderTexture.indexOfTexSetToRender = i;
atlasRenderTexture.texPropertyName = data.texPropertyNames[i];
atlasRenderTexture.isNormalMap = data.texPropertyNames[i].isNormalMap;
atlasRenderTexture.fixOutOfBoundsUVs = data._fixOutOfBoundsUVs;
atlasRenderTexture.considerNonTextureProperties = data._considerNonTextureProperties;
atlasRenderTexture.resultMaterialTextureBlender = data.nonTexturePropertyBlender;
// call render on it
atlas = atlasRenderTexture.OnRenderAtlas(combiner);
// destroy it
// =============
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Saving atlas " + data.texPropertyNames[i].name + " w=" + atlas.width + " h=" + atlas.height + " id=" + atlas.GetInstanceID());
}
}
atlases[i] = atlas;
if (progressInfo != null)
{
progressInfo("Saving atlas: '" + data.texPropertyNames[i].name + "'", .04f);
}
if (data._saveAtlasesAsAssets && textureEditorMethods != null)
{
textureEditorMethods.SaveAtlasToAssetDatabase(atlases[i], data.texPropertyNames[i], i, data.resultMaterial);
}
else
{
data.resultMaterial.SetTexture(data.texPropertyNames[i].name, atlases[i]);
}
data.resultMaterial.SetTextureOffset(data.texPropertyNames[i].name, Vector2.zero);
data.resultMaterial.SetTextureScale(data.texPropertyNames[i].name, Vector2.one);
combiner._destroyTemporaryTextures(); // need to save atlases before doing this
}
}
catch (Exception ex)
{
//Debug.LogError(ex);
Debug.LogException(ex);
}
finally
{
if (renderAtlasesGO != null)
{
MB_Utility.Destroy(renderAtlasesGO);
}
}
}
yield break;
}
internal static IEnumerator CopyScaledAndTiledToAtlas(MeshBakerMaterialTexture source, MB_TexSet sourceMaterial,
ShaderTextureProperty shaderPropertyName, DRect srcSamplingRect, int targX, int targY, int targW, int targH,
AtlasPadding padding,
Color[][] atlasPixels, bool isNormalMap,
MB3_TextureCombinerPipeline.TexturePipelineData data,
MB3_TextureCombiner combiner,
ProgressUpdateDelegate progressInfo = null,
MB2_LogLevel LOG_LEVEL = MB2_LogLevel.info)
{
//HasFinished = false;
Texture2D t = source.GetTexture2D();
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log(String.Format("CopyScaledAndTiledToAtlas: {0} inAtlasX={1} inAtlasY={2} inAtlasW={3} inAtlasH={4} paddX={5} paddY={6} srcSamplingRect={7}",
t, targX, targY, targW, targH, padding.leftRight, padding.topBottom, srcSamplingRect));
}
float newWidth = targW;
float newHeight = targH;
float scx = (float)srcSamplingRect.width;
float scy = (float)srcSamplingRect.height;
float ox = (float)srcSamplingRect.x;
float oy = (float)srcSamplingRect.y;
int w = (int)newWidth;
int h = (int)newHeight;
if (data._considerNonTextureProperties)
{
t = combiner._createTextureCopy(shaderPropertyName.name, t);
t = data.nonTexturePropertyBlender.TintTextureWithTextureCombiner(t, sourceMaterial, shaderPropertyName);
}
for (int i = 0; i < w; i++)
{
if (progressInfo != null && w > 0)
{
progressInfo("CopyScaledAndTiledToAtlas " + (((float)i / (float)w) * 100f).ToString("F0"), .2f);
}
for (int j = 0; j < h; j++)
{
float u = i / newWidth * scx + ox;
float v = j / newHeight * scy + oy;
atlasPixels[targY + j][targX + i] = t.GetPixelBilinear(u, v);
}
}
//bleed the border colors into the padding
for (int i = 0; i < w; i++)
{
for (int j = 1; j <= padding.topBottom; j++)
{
//top margin
atlasPixels[(targY - j)][targX + i] = atlasPixels[(targY)][targX + i];
//bottom margin
atlasPixels[(targY + h - 1 + j)][targX + i] = atlasPixels[(targY + h - 1)][targX + i];
}
}
for (int j = 0; j < h; j++)
{
for (int i = 1; i <= padding.leftRight; i++)
{
//left margin
atlasPixels[(targY + j)][targX - i] = atlasPixels[(targY + j)][targX];
//right margin
atlasPixels[(targY + j)][targX + w + i - 1] = atlasPixels[(targY + j)][targX + w - 1];
}
}
//corners
for (int i = 1; i <= padding.leftRight; i++)
{
for (int j = 1; j <= padding.topBottom; j++)
{
atlasPixels[(targY - j)][targX - i] = atlasPixels[targY][targX];
atlasPixels[(targY + h - 1 + j)][targX - i] = atlasPixels[(targY + h - 1)][targX];
atlasPixels[(targY + h - 1 + j)][targX + w + i - 1] = atlasPixels[(targY + h - 1)][targX + w - 1];
atlasPixels[(targY - j)][targX + w + i - 1] = atlasPixels[targY][targX + w - 1];
yield return(null);
}
yield return(null);
}
// Debug.Log("copyandscaledatlas finished too!");
//HasFinished = true;
yield break;
}
public override IEnumerator CreateAtlases(ProgressUpdateDelegate progressInfo,
MB3_TextureCombinerPipeline.TexturePipelineData data, MB3_TextureCombiner combiner,
AtlasPackingResult packedAtlasRects,
Texture2D[] atlases, MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
Rect[] uvRects = packedAtlasRects.rects;
int atlasSizeX = packedAtlasRects.atlasX;
int atlasSizeY = packedAtlasRects.atlasY;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Generated atlas will be " + atlasSizeX + "x" + atlasSizeY);
}
for (int propIdx = 0; propIdx < data.numAtlases; propIdx++)
{
Texture2D atlas = null;
ShaderTextureProperty property = data.texPropertyNames[propIdx];
if (!MB3_TextureCombinerPipeline._ShouldWeCreateAtlasForThisProperty(propIdx, data._considerNonTextureProperties, data.allTexturesAreNullAndSameColor))
{
atlas = null;
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("=== Not creating atlas for " + property.name + " because textures are null and default value parameters are the same.");
}
}
else
{
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("=== Creating atlas for " + property.name);
}
GC.Collect();
CreateTemporaryTexturesForAtlas(data.distinctMaterialTextures, combiner, propIdx, data);
//use a jagged array because it is much more efficient in memory
Color[][] atlasPixels = new Color[atlasSizeY][];
for (int j = 0; j < atlasPixels.Length; j++)
{
atlasPixels[j] = new Color[atlasSizeX];
}
bool isNormalMap = false;
if (property.isNormalMap)
{
isNormalMap = true;
}
for (int texSetIdx = 0; texSetIdx < data.distinctMaterialTextures.Count; texSetIdx++)
{
MB_TexSet texSet = data.distinctMaterialTextures[texSetIdx];
MeshBakerMaterialTexture matTex = texSet.ts[propIdx];
string s = "Creating Atlas '" + property.name + "' texture " + matTex.GetTexName();
if (progressInfo != null)
{
progressInfo(s, .01f);
}
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log(string.Format("Adding texture {0} to atlas {1} for texSet {2} srcMat {3}", matTex.GetTexName(), property.name, texSetIdx, texSet.matsAndGOs.mats[0].GetMaterialName()));
}
Rect r = uvRects[texSetIdx];
Texture2D t = texSet.ts[propIdx].GetTexture2D();
int x = Mathf.RoundToInt(r.x * atlasSizeX);
int y = Mathf.RoundToInt(r.y * atlasSizeY);
int ww = Mathf.RoundToInt(r.width * atlasSizeX);
int hh = Mathf.RoundToInt(r.height * atlasSizeY);
if (ww == 0 || hh == 0)
{
Debug.LogError("Image in atlas has no height or width " + r);
}
if (progressInfo != null)
{
progressInfo(s + " set ReadWrite flag", .01f);
}
if (textureEditorMethods != null)
{
textureEditorMethods.SetReadWriteFlag(t, true, true);
}
if (progressInfo != null)
{
progressInfo(s + "Copying to atlas: '" + matTex.GetTexName() + "'", .02f);
}
DRect samplingRect = texSet.ts[propIdx].GetEncapsulatingSamplingRect();
Debug.Assert(!texSet.ts[propIdx].isNull, string.Format("Adding texture {0} to atlas {1} for texSet {2} srcMat {3}", matTex.GetTexName(), property.name, texSetIdx, texSet.matsAndGOs.mats[0].GetMaterialName()));
yield return(CopyScaledAndTiledToAtlas(texSet.ts[propIdx], texSet, property, samplingRect, x, y, ww, hh, packedAtlasRects.padding[texSetIdx], atlasPixels, isNormalMap, data, combiner, progressInfo, LOG_LEVEL));
}
yield return(data.numAtlases);
if (progressInfo != null)
{
progressInfo("Applying changes to atlas: '" + property.name + "'", .03f);
}
atlas = new Texture2D(atlasSizeX, atlasSizeY, TextureFormat.ARGB32, true);
for (int j = 0; j < atlasPixels.Length; j++)
{
atlas.SetPixels(0, j, atlasSizeX, 1, atlasPixels[j]);
}
atlas.Apply();
if (LOG_LEVEL >= MB2_LogLevel.debug)
{
Debug.Log("Saving atlas " + property.name + " w=" + atlas.width + " h=" + atlas.height);
}
}
atlases[propIdx] = atlas;
if (progressInfo != null)
{
progressInfo("Saving atlas: '" + property.name + "'", .04f);
}
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
sw.Start();
if (data.resultType == MB2_TextureBakeResults.ResultType.atlas)
{
SaveAtlasAndConfigureResultMaterial(data, textureEditorMethods, atlases[propIdx], data.texPropertyNames[propIdx], propIdx);
}
combiner._destroyTemporaryTextures(data.texPropertyNames[propIdx].name);
}
yield break;
}
internal static void BuildAtlas(
AtlasPackingResult packedAtlasRects,
List <MB_TexSet> distinctMaterialTextures,
int propIdx,
int atlasSizeX, int atlasSizeY,
Mesh m,
List <Material> generatedMats,
ShaderTextureProperty property,
MB3_TextureCombinerPipeline.TexturePipelineData data,
MB3_TextureCombiner combiner,
MB2_EditorMethodsInterface textureEditorMethods,
MB2_LogLevel LOG_LEVEL)
{
// Collect vertices and quads for mesh that we will use for the atlas.
Debug.Assert(generatedMats.Count == 0, "Previous mats should have been destroyed");
generatedMats.Clear();
List <Vector3> vs = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
// One submesh and material per texture that we are packing
List <int>[] ts = new List <int> [distinctMaterialTextures.Count];
for (int i = 0; i < ts.Length; i++)
{
ts[i] = new List <int>();
}
MeshBakerMaterialTexture.readyToBuildAtlases = true;
GC.Collect();
MB3_TextureCombinerPackerRoot.CreateTemporaryTexturesForAtlas(data.distinctMaterialTextures, combiner, propIdx, data);
Rect[] uvRects = packedAtlasRects.rects;
for (int texSetIdx = 0; texSetIdx < distinctMaterialTextures.Count; texSetIdx++)
{
MB_TexSet texSet = distinctMaterialTextures[texSetIdx];
MeshBakerMaterialTexture matTex = texSet.ts[propIdx];
if (LOG_LEVEL >= MB2_LogLevel.trace)
{
Debug.Log(string.Format("Adding texture {0} to atlas {1} for texSet {2} srcMat {3}", matTex.GetTexName(), property.name, texSetIdx, texSet.matsAndGOs.mats[0].GetMaterialName()));
}
Rect r = uvRects[texSetIdx];
Texture2D t = matTex.GetTexture2D();
int x = Mathf.RoundToInt(r.x * atlasSizeX);
int y = Mathf.RoundToInt(r.y * atlasSizeY);
int ww = Mathf.RoundToInt(r.width * atlasSizeX);
int hh = Mathf.RoundToInt(r.height * atlasSizeY);
r = new Rect(x, y, ww, hh);
if (ww == 0 || hh == 0)
{
Debug.LogError("Image in atlas has no height or width " + r);
}
DRect samplingRect = texSet.ts[propIdx].GetEncapsulatingSamplingRect();
Debug.Assert(!texSet.ts[propIdx].isNull, string.Format("Adding texture {0} to atlas {1} for texSet {2} srcMat {3}", matTex.GetTexName(), property.name, texSetIdx, texSet.matsAndGOs.mats[0].GetMaterialName()));
AtlasPadding padding = packedAtlasRects.padding[texSetIdx];
AddNineSlicedRect(r, padding.leftRight, padding.topBottom, samplingRect.GetRect(), vs, uvs, ts[texSetIdx], t.width, t.height, t.name);
Material mt = new Material(Shader.Find("MeshBaker/Unlit/UnlitWithAlpha"));
bool isSavingAsANormalMapAssetThatWillBeImported = property.isNormalMap && data._saveAtlasesAsAssets;
MBVersion.PipelineType pipelineType = MBVersion.DetectPipeline();
if (pipelineType == MBVersion.PipelineType.URP)
{
ConfigureMaterial_DefaultPipeline(mt, t, isSavingAsANormalMapAssetThatWillBeImported, LOG_LEVEL);
//ConfigureMaterial_URP(mt, t, isSavingAsANormalMapAssetThatWillBeImported, LOG_LEVEL);
}
else if (pipelineType == MBVersion.PipelineType.HDRP)
{
ConfigureMaterial_DefaultPipeline(mt, t, isSavingAsANormalMapAssetThatWillBeImported, LOG_LEVEL);
}
else
{
ConfigureMaterial_DefaultPipeline(mt, t, isSavingAsANormalMapAssetThatWillBeImported, LOG_LEVEL);
}
generatedMats.Add(mt);
}
// Apply to the mesh
m.Clear();
m.vertices = vs.ToArray();
m.uv = uvs.ToArray();
m.subMeshCount = ts.Length;
for (int i = 0; i < m.subMeshCount; i++)
{
m.SetIndices(ts[i].ToArray(), MeshTopology.Triangles, i);
}
MeshBakerMaterialTexture.readyToBuildAtlases = false;
}
