protected override void Start()
{
backUpTexture = umaGenerator.umaData.backUpTextures();
umaGenerator.umaData.cleanTextures();
materialDefinitionList = new List<UMAData.MaterialDefinition>();
//Update atlas area can be handled here
UMAData.MaterialDefinition tempMaterialDefinition = new UMAData.MaterialDefinition();
SlotData[] slots = umaGenerator.umaData.umaRecipe.slotDataList;
for(int i = 0; i < slots.Length; i++){
if(slots[i] != null){
tempMaterialDefinition = new UMAData.MaterialDefinition();
tempMaterialDefinition.baseTexture = slots[i].GetOverlay(0).textureList;
tempMaterialDefinition.baseColor = slots[i].GetOverlay(0).color;
tempMaterialDefinition.materialSample = slots[i].materialSample;
tempMaterialDefinition.overlays = new UMAData.textureData[slots[i].OverlayCount -1];
tempMaterialDefinition.overlayColors = new Color32[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.rects = new Rect[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.channelMask = new Color32[tempMaterialDefinition.overlays.Length+1][];
tempMaterialDefinition.channelAdditiveMask = new Color32[tempMaterialDefinition.overlays.Length+1][];
tempMaterialDefinition.channelMask[0] = slots[i].GetOverlay(0).channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slots[i].GetOverlay(0).channelAdditiveMask;
tempMaterialDefinition.slotData = slots[i];
for(int overlayID = 0; overlayID < slots[i].OverlayCount-1; overlayID++){
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.rects[overlayID] = slots[i].GetOverlay(overlayID+1).rect;
tempMaterialDefinition.overlays[overlayID].textureList = slots[i].GetOverlay(overlayID+1).textureList;
tempMaterialDefinition.overlayColors[overlayID] = slots[i].GetOverlay(overlayID+1).color;
tempMaterialDefinition.channelMask[overlayID+1] = slots[i].GetOverlay(overlayID + 1).channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID+1] = slots[i].GetOverlay(overlayID + 1).channelAdditiveMask;
}
materialDefinitionList.Add(tempMaterialDefinition);
}
}
if(umaGenerator.usePRO){
textureProcessPROCoroutine = new TextureProcessPROCoroutine();
}else{
textureProcessIndieCoroutine = new TextureProcessIndieCoroutine();
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution,umaGenerator.atlasResolution,false);
}
protected override void Start()
{
if (generatedMaterialLookup == null)
{
generatedMaterialLookup = new Dictionary <GeneratedMaterialLookupKey, UMAData.GeneratedMaterial>(20);
}
else
{
generatedMaterialLookup.Clear();
}
backUpTexture = umaData.backUpTextures();
umaData.CleanTextures();
generatedMaterials = new List <UMAData.GeneratedMaterial>(20);
atlassedMaterials.Clear();
uniqueRenderers.Clear();
SlotData[] slots = umaData.umaRecipe.slotDataList;
for (int i = 0; i < slots.Length; i++)
{
SlotData slot = slots[i];
if (slot == null)
{
continue;
}
if (slot.Suppressed)
{
continue;
}
//Keep a running list of unique RendererHashes from our slots
//Null rendererAsset gets added, which is good, it is the default renderer.
if (!uniqueRenderers.Contains(slot.rendererAsset))
{
uniqueRenderers.Add(slot.rendererAsset);
}
// Let's only add the default overlay if the slot has meshData and NO overlays
// This should be able to be removed if default overlay/textures are ever added to uma materials...
if ((slot.asset.meshData != null) && (slot.OverlayCount == 0))
{
if (umaGenerator.defaultOverlaydata != null)
{
slot.AddOverlay(umaGenerator.defaultOverlaydata);
}
}
OverlayData overlay0 = slot.GetOverlay(0);
if ((slot.asset.material != null) && (overlay0 != null))
{
GeneratedMaterialLookupKey lookupKey = new GeneratedMaterialLookupKey
{
overlayList = slot.GetOverlayList(),
rendererAsset = slot.rendererAsset
};
UMAData.GeneratedMaterial generatedMaterial;
if (!generatedMaterialLookup.TryGetValue(lookupKey, out generatedMaterial))
{
generatedMaterial = FindOrCreateGeneratedMaterial(slot.asset.material, slot.rendererAsset);
generatedMaterialLookup.Add(lookupKey, generatedMaterial);
}
int validOverlayCount = 0;
for (int j = 0; j < slot.OverlayCount; j++)
{
var overlay = slot.GetOverlay(j);
if (overlay != null)
{
validOverlayCount++;
#if (UNITY_STANDALONE || UNITY_IOS || UNITY_ANDROID || UNITY_PS4 || UNITY_XBOXONE) && !UNITY_2017_3_OR_NEWER //supported platforms for procedural materials
if (overlay.isProcedural)
{
overlay.GenerateProceduralTextures();
}
#endif
}
}
UMAData.MaterialFragment tempMaterialDefinition = new UMAData.MaterialFragment();
tempMaterialDefinition.baseOverlay = new UMAData.textureData();
tempMaterialDefinition.baseOverlay.textureList = overlay0.textureArray;
tempMaterialDefinition.baseOverlay.alphaTexture = overlay0.alphaMask;
tempMaterialDefinition.baseOverlay.overlayType = overlay0.overlayType;
tempMaterialDefinition.umaMaterial = slot.asset.material;
tempMaterialDefinition.baseColor = overlay0.colorData.color;
tempMaterialDefinition.size = overlay0.pixelCount;
tempMaterialDefinition.overlays = new UMAData.textureData[validOverlayCount - 1];
tempMaterialDefinition.overlayColors = new Color32[validOverlayCount - 1];
tempMaterialDefinition.rects = new Rect[validOverlayCount - 1];
tempMaterialDefinition.overlayData = new OverlayData[validOverlayCount];
tempMaterialDefinition.channelMask = new Color[validOverlayCount][];
tempMaterialDefinition.channelAdditiveMask = new Color[validOverlayCount][];
tempMaterialDefinition.overlayData[0] = slot.GetOverlay(0);
tempMaterialDefinition.channelMask[0] = slot.GetOverlay(0).colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slot.GetOverlay(0).colorData.channelAdditiveMask;
tempMaterialDefinition.slotData = slot;
int overlayID = 0;
for (int j = 1; j < slot.OverlayCount; j++)
{
OverlayData overlay = slot.GetOverlay(j);
if (overlay == null)
{
continue;
}
if (IsUVCoordinates(overlay.rect))
{
tempMaterialDefinition.rects[overlayID] = ScaleToBase(overlay.rect, overlay0.textureArray[0]);
}
else
{
tempMaterialDefinition.rects[overlayID] = overlay.rect; // JRRM: Convert here into base overlay coordinates?
}
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.overlays[overlayID].textureList = overlay.textureArray;
tempMaterialDefinition.overlays[overlayID].alphaTexture = overlay.alphaMask;
tempMaterialDefinition.overlays[overlayID].overlayType = overlay.overlayType;
tempMaterialDefinition.overlayColors[overlayID] = overlay.colorData.color;
overlayID++;
tempMaterialDefinition.overlayData[overlayID] = overlay;
tempMaterialDefinition.channelMask[overlayID] = overlay.colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID] = overlay.colorData.channelAdditiveMask;
}
tempMaterialDefinition.overlayList = lookupKey.overlayList;
tempMaterialDefinition.isRectShared = false;
for (int j = 0; j < generatedMaterial.materialFragments.Count; j++)
{
if (tempMaterialDefinition.overlayList == generatedMaterial.materialFragments[j].overlayList)
{
tempMaterialDefinition.isRectShared = true;
tempMaterialDefinition.rectFragment = generatedMaterial.materialFragments[j];
break;
}
}
generatedMaterial.materialFragments.Add(tempMaterialDefinition);
}
}
//****************************************************
//* Set parameters based on shader parameter mapping
//****************************************************
for (int i = 0; i < generatedMaterials.Count; i++)
{
UMAData.GeneratedMaterial ugm = generatedMaterials[i];
if (ugm.umaMaterial.shaderParms != null)
{
for (int j = 0; j < ugm.umaMaterial.shaderParms.Length; j++)
{
UMAMaterial.ShaderParms parm = ugm.umaMaterial.shaderParms[j];
if (ugm.material.HasProperty(parm.ParameterName))
{
foreach (OverlayColorData ocd in umaData.umaRecipe.sharedColors)
{
if (ocd.name == parm.ColorName)
{
ugm.material.SetColor(parm.ParameterName, ocd.color);
break;
}
}
}
}
}
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution, umaGenerator.atlasResolution, false);
}
protected override void Start()
{
if (generatedMaterialLookup == null)
{
generatedMaterialLookup = new Dictionary <List <OverlayData>, UMAData.GeneratedMaterial>(20);
}
else
{
generatedMaterialLookup.Clear();
}
backUpTexture = umaData.backUpTextures();
umaData.CleanTextures();
generatedMaterials = new List <UMAData.GeneratedMaterial>(20);
atlassedMaterials.Clear();
SlotData[] slots = umaData.umaRecipe.slotDataList;
for (int i = 0; i < slots.Length; i++)
{
var slot = slots[i];
if (slot == null)
{
continue;
}
if (slot.asset.material != null && slot.GetOverlay(0) != null)
{
var overlayList = slot.GetOverlayList();
UMAData.GeneratedMaterial generatedMaterial;
if (!generatedMaterialLookup.TryGetValue(overlayList, out generatedMaterial))
{
generatedMaterial = FindOrCreateGeneratedMaterial(slots[i].asset.material);
generatedMaterialLookup.Add(overlayList, generatedMaterial);
}
var tempMaterialDefinition = new UMAData.MaterialFragment();
tempMaterialDefinition.baseTexture = slots[i].GetOverlay(0).asset.textureList;
tempMaterialDefinition.size = tempMaterialDefinition.baseTexture[0].width * tempMaterialDefinition.baseTexture[0].height;
tempMaterialDefinition.baseColor = slots[i].GetOverlay(0).colorData.color;
tempMaterialDefinition.umaMaterial = slots[i].asset.material;
int overlays = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter);
if (overlay != null)
{
overlays++;
}
}
tempMaterialDefinition.overlays = new UMAData.textureData[overlays - 1];
tempMaterialDefinition.overlayColors = new Color32[overlays - 1];
tempMaterialDefinition.rects = new Rect[overlays - 1];
tempMaterialDefinition.overlayData = new OverlayData[overlays];
tempMaterialDefinition.channelMask = new Color[overlays][];
tempMaterialDefinition.channelAdditiveMask = new Color[overlays][];
tempMaterialDefinition.overlayData[0] = slots[i].GetOverlay(0);
tempMaterialDefinition.channelMask[0] = slots[i].GetOverlay(0).colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slots[i].GetOverlay(0).colorData.channelAdditiveMask;
tempMaterialDefinition.slotData = slots[i];
int overlayID = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount - 1; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter + 1);
if (overlay == null)
{
continue;
}
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.rects[overlayID] = overlay.rect;
tempMaterialDefinition.overlays[overlayID].textureList = overlay.asset.textureList;
tempMaterialDefinition.overlayColors[overlayID] = overlay.colorData.color;
tempMaterialDefinition.channelMask[overlayID + 1] = overlay.colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID + 1] = overlay.colorData.channelAdditiveMask;
tempMaterialDefinition.overlayData[overlayID + 1] = overlay;
overlayID++;
}
tempMaterialDefinition.overlayList = slots[i].GetOverlayList();
tempMaterialDefinition.isRectShared = false;
for (int j = 0; j < generatedMaterial.materialFragments.Count; j++)
{
if (generatedMaterial.materialFragments[j].overlayList == tempMaterialDefinition.overlayList)
{
tempMaterialDefinition.isRectShared = true;
tempMaterialDefinition.rectFragment = generatedMaterial.materialFragments[j];
break;
}
}
generatedMaterial.materialFragments.Add(tempMaterialDefinition);
}
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution, umaGenerator.atlasResolution, false);
}
protected override void Start()
{
if (generatedMaterialLookup == null)
{
generatedMaterialLookup = new Dictionary <List <OverlayData>, UMAData.GeneratedMaterial>(20);
}
else
{
generatedMaterialLookup.Clear();
}
backUpTexture = umaData.backUpTextures();
umaData.CleanTextures();
generatedMaterials = new List <UMAData.GeneratedMaterial>(20);
atlassedMaterials.Clear();
rendererCount = 0;
SlotData[] slots = umaData.umaRecipe.slotDataList;
for (int i = 0; i < slots.Length; i++)
{
var slot = slots[i];
if (slot == null)
{
continue;
}
if ((slot.asset.material != null) && (slot.GetOverlay(0) != null))
{
if (!slot.asset.material.RequireSeperateRenderer)
{
// At least one slot that doesn't require a seperate renderer, so we reserve renderer 0 for those.
rendererCount = 1;
break;
}
}
}
for (int i = 0; i < slots.Length; i++)
{
SlotData slot = slots[i];
if (slot == null)
{
continue;
}
// Let's only add the default overlay if the slot has overlays and NO meshData
if ((slot.asset.meshData != null) && (slot.OverlayCount == 0))
{
if (umaGenerator.defaultOverlaydata != null)
{
slot.AddOverlay(umaGenerator.defaultOverlaydata);
}
}
OverlayData overlay0 = slot.GetOverlay(0);
if ((slot.asset.material != null) && (overlay0 != null))
{
List <OverlayData> overlayList = slot.GetOverlayList();
UMAData.GeneratedMaterial generatedMaterial;
if (!generatedMaterialLookup.TryGetValue(overlayList, out generatedMaterial))
{
generatedMaterial = FindOrCreateGeneratedMaterial(slot.asset.material);
generatedMaterialLookup.Add(overlayList, generatedMaterial);
}
int validOverlayCount = 0;
for (int j = 0; j < slot.OverlayCount; j++)
{
var overlay = slot.GetOverlay(j);
if (overlay != null)
{
validOverlayCount++;
#if UNITY_STANDALONE || UNITY_IOS || UNITY_ANDROID || UNITY_PS4 || UNITY_XBOXONE //supported platforms for procedural materials
if (overlay.isProcedural)
{
overlay.GenerateProceduralTextures();
}
#endif
}
}
UMAData.MaterialFragment tempMaterialDefinition = new UMAData.MaterialFragment();
tempMaterialDefinition.baseOverlay = new UMAData.textureData();
tempMaterialDefinition.baseOverlay.textureList = overlay0.textureArray;
tempMaterialDefinition.baseOverlay.alphaTexture = overlay0.alphaMask;
tempMaterialDefinition.baseOverlay.overlayType = overlay0.overlayType;
tempMaterialDefinition.umaMaterial = slot.asset.material;
tempMaterialDefinition.baseColor = overlay0.colorData.color;
tempMaterialDefinition.size = overlay0.pixelCount;
tempMaterialDefinition.overlays = new UMAData.textureData[validOverlayCount - 1];
tempMaterialDefinition.overlayColors = new Color32[validOverlayCount - 1];
tempMaterialDefinition.rects = new Rect[validOverlayCount - 1];
tempMaterialDefinition.overlayData = new OverlayData[validOverlayCount];
tempMaterialDefinition.channelMask = new Color[validOverlayCount][];
tempMaterialDefinition.channelAdditiveMask = new Color[validOverlayCount][];
tempMaterialDefinition.overlayData[0] = slot.GetOverlay(0);
tempMaterialDefinition.channelMask[0] = slot.GetOverlay(0).colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slot.GetOverlay(0).colorData.channelAdditiveMask;
tempMaterialDefinition.slotData = slot;
int overlayID = 0;
for (int j = 1; j < slot.OverlayCount; j++)
{
OverlayData overlay = slot.GetOverlay(j);
if (overlay == null)
{
continue;
}
tempMaterialDefinition.rects[overlayID] = overlay.rect;
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.overlays[overlayID].textureList = overlay.textureArray;
tempMaterialDefinition.overlays[overlayID].alphaTexture = overlay.alphaMask;
tempMaterialDefinition.overlays[overlayID].overlayType = overlay.overlayType;
tempMaterialDefinition.overlayColors[overlayID] = overlay.colorData.color;
overlayID++;
tempMaterialDefinition.overlayData[overlayID] = overlay;
tempMaterialDefinition.channelMask[overlayID] = overlay.colorData.channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID] = overlay.colorData.channelAdditiveMask;
}
tempMaterialDefinition.overlayList = overlayList;
tempMaterialDefinition.isRectShared = false;
for (int j = 0; j < generatedMaterial.materialFragments.Count; j++)
{
if (tempMaterialDefinition.overlayList == generatedMaterial.materialFragments[j].overlayList)
{
tempMaterialDefinition.isRectShared = true;
tempMaterialDefinition.rectFragment = generatedMaterial.materialFragments[j];
break;
}
}
generatedMaterial.materialFragments.Add(tempMaterialDefinition);
}
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution, umaGenerator.atlasResolution, false);
}
protected override void Start()
{
backUpTexture = umaData.backUpTextures();
umaData.cleanTextures();
materialDefinitionList = new List <UMAData.MaterialDefinition>();
//Update atlas area can be handled here
UMAData.MaterialDefinition tempMaterialDefinition = new UMAData.MaterialDefinition();
SlotData[] slots = umaData.umaRecipe.slotDataList;
for (int i = 0; i < slots.Length; i++)
{
if (slots[i] == null)
{
continue;
}
if (slots[i].textureNameList.Length == 1 && string.IsNullOrEmpty(slots[i].textureNameList[0]))
{
continue;
}
if (slots[i].GetOverlay(0) != null)
{
tempMaterialDefinition = new UMAData.MaterialDefinition();
tempMaterialDefinition.baseTexture = slots[i].GetOverlay(0).textureList;
tempMaterialDefinition.baseColor = slots[i].GetOverlay(0).color;
tempMaterialDefinition.materialSample = slots[i].materialSample;
int overlays = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter);
if (overlay != null)
{
overlays++;
if (overlay.useAdvancedMasks)
{
overlay.EnsureChannels(slots[i].textureNameList.Length);
}
}
}
tempMaterialDefinition.overlays = new UMAData.textureData[overlays - 1];
tempMaterialDefinition.overlayColors = new Color32[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.rects = new Rect[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.channelMask = new Color32[tempMaterialDefinition.overlays.Length + 1][];
tempMaterialDefinition.channelAdditiveMask = new Color32[tempMaterialDefinition.overlays.Length + 1][];
tempMaterialDefinition.channelMask[0] = slots[i].GetOverlay(0).channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slots[i].GetOverlay(0).channelAdditiveMask;
tempMaterialDefinition.slotData = slots[i];
int overlayID = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount - 1; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter + 1);
if (overlay == null)
{
continue;
}
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.rects[overlayID] = overlay.rect;
tempMaterialDefinition.overlays[overlayID].textureList = overlay.textureList;
tempMaterialDefinition.overlayColors[overlayID] = overlay.color;
tempMaterialDefinition.channelMask[overlayID + 1] = overlay.channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID + 1] = overlay.channelAdditiveMask;
overlayID++;
}
materialDefinitionList.Add(tempMaterialDefinition);
}
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution, umaGenerator.atlasResolution, false);
}
protected override void Start()
{
backUpTexture = umaData.backUpTextures();
umaData.cleanTextures();
materialDefinitionList = new List<UMAData.MaterialDefinition>();
//Update atlas area can be handled here
UMAData.MaterialDefinition tempMaterialDefinition = new UMAData.MaterialDefinition();
SlotData[] slots = umaData.umaRecipe.slotDataList;
for(int i = 0; i < slots.Length; i++)
{
if (slots[i] != null && slots[i].GetOverlay(0) != null)
{
tempMaterialDefinition = new UMAData.MaterialDefinition();
tempMaterialDefinition.baseTexture = slots[i].GetOverlay(0).textureList;
tempMaterialDefinition.baseColor = slots[i].GetOverlay(0).color;
tempMaterialDefinition.materialSample = slots[i].materialSample;
int overlays = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter);
if (overlay != null)
{
overlays++;
if (overlay.useAdvancedMasks)
{
overlay.EnsureChannels(slots[i].textureNameList.Length);
}
}
}
tempMaterialDefinition.overlays = new UMAData.textureData[overlays - 1];
tempMaterialDefinition.overlayColors = new Color32[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.rects = new Rect[tempMaterialDefinition.overlays.Length];
tempMaterialDefinition.channelMask = new Color32[tempMaterialDefinition.overlays.Length+1][];
tempMaterialDefinition.channelAdditiveMask = new Color32[tempMaterialDefinition.overlays.Length+1][];
tempMaterialDefinition.channelMask[0] = slots[i].GetOverlay(0).channelMask;
tempMaterialDefinition.channelAdditiveMask[0] = slots[i].GetOverlay(0).channelAdditiveMask;
tempMaterialDefinition.slotData = slots[i];
int overlayID = 0;
for (int overlayCounter = 0; overlayCounter < slots[i].OverlayCount - 1; overlayCounter++)
{
var overlay = slots[i].GetOverlay(overlayCounter + 1);
if (overlay == null) continue;
tempMaterialDefinition.overlays[overlayID] = new UMAData.textureData();
tempMaterialDefinition.rects[overlayID] = overlay.rect;
tempMaterialDefinition.overlays[overlayID].textureList = overlay.textureList;
tempMaterialDefinition.overlayColors[overlayID] = overlay.color;
tempMaterialDefinition.channelMask[overlayID+1] = overlay.channelMask;
tempMaterialDefinition.channelAdditiveMask[overlayID+1] = overlay.channelAdditiveMask;
overlayID++;
}
materialDefinitionList.Add(tempMaterialDefinition);
}
}
packTexture = new MaxRectsBinPack(umaGenerator.atlasResolution,umaGenerator.atlasResolution,false);
}
