示例#1
0
 public void SetOverlayColorData(OverlayColorData overlayColorData)
 {
     overlayColorData.name = name;
     if (UMAPackRecipe.ArrayHasData(masks))
     {
         int channelCount = masks.Length;
         overlayColorData.channelMask         = new Color[channelCount];
         overlayColorData.channelAdditiveMask = new Color[channelCount];
         for (int channel = 0; channel < channelCount; channel++)
         {
             overlayColorData.channelMask[channel].r         = masks[channel][0] / 255f;
             overlayColorData.channelMask[channel].g         = masks[channel][1] / 255f;
             overlayColorData.channelMask[channel].b         = masks[channel][2] / 255f;
             overlayColorData.channelMask[channel].a         = masks[channel][3] / 255f;
             overlayColorData.channelAdditiveMask[channel].r = addMasks[channel][0];
             overlayColorData.channelAdditiveMask[channel].g = addMasks[channel][1];
             overlayColorData.channelAdditiveMask[channel].b = addMasks[channel][2];
             overlayColorData.channelAdditiveMask[channel].a = addMasks[channel][3];
         }
     }
     else
     {
         overlayColorData.channelMask         = new Color[1];
         overlayColorData.channelAdditiveMask = new Color[1];
         overlayColorData.channelMask[0]      = new Color(color[0] / 255f, color[1] / 255f, color[2] / 255f, color[3] / 255f);
     }
 }
示例#2
0
 public PackedOverlayColorDataV2(OverlayColorData colorData)
 {
     name     = colorData.name;
     color    = new byte[4];
     color[0] = (byte)Mathf.FloorToInt(colorData.color.r * 255f);
     color[1] = (byte)Mathf.FloorToInt(colorData.color.g * 255f);
     color[2] = (byte)Mathf.FloorToInt(colorData.color.b * 255f);
     color[3] = (byte)Mathf.FloorToInt(colorData.color.a * 255f);
     if (UMAPackRecipe.ArrayHasData(colorData.channelMask))
     {
         int channelCount = colorData.channelMask.Length;
         masks    = new byte[channelCount][];
         addMasks = new byte[channelCount][];
         for (int channel = 0; channel < channelCount; channel++)
         {
             masks[channel]    = new byte[4];
             addMasks[channel] = new byte[4];
             Color32 maskColor = colorData.channelMask[channel];
             masks[channel][0] = maskColor.r;
             masks[channel][1] = maskColor.g;
             masks[channel][2] = maskColor.b;
             masks[channel][3] = maskColor.a;
             Color32 additiveMaskColor = colorData.channelAdditiveMask[channel];
             addMasks[channel][0] = additiveMaskColor.r;
             addMasks[channel][1] = additiveMaskColor.g;
             addMasks[channel][2] = additiveMaskColor.b;
             addMasks[channel][3] = additiveMaskColor.a;
         }
     }
 }
示例#3
0
 /// <summary>
 /// Convert an UMAPackRecipe into a DCSUniversalPackRecipe. Used when DCS needs to load an old UMA
 /// </summary>
 /// <param name="umaPackRecipe"></param>
 /// <param name="recipeType"></param>
 public DCSUniversalPackRecipe(UMAPackRecipe umaPackRecipe, string pRecipeType = "Standard")
 {
     //Debug.Log("Created universal model from UMAPackRecipe");
     packedRecipeType   = pRecipeType;
     version            = umaPackRecipe.version;
     packedSlotDataList = umaPackRecipe.packedSlotDataList;
     slotsV2            = umaPackRecipe.slotsV2;
     colors             = umaPackRecipe.colors;
     fColors            = umaPackRecipe.fColors;
     sharedColorCount   = umaPackRecipe.sharedColorCount;
     race      = umaPackRecipe.race;
     umaDna    = umaPackRecipe.umaDna;
     packedDna = umaPackRecipe.packedDna;
 }
示例#4
0
 /// <summary>
 /// Converts standard UMA Pack Recipe data into this data model, either when loading an old recipe, or when the RecipeEditor is saving a DCS recipe asset
 /// </summary>
 /// <param name="umaPackRecipe"></param>
 /// <param name="recipeName"></param>
 /// <param name="recipeType"></param>
 /// <param name="wardrobeSetToSave"></param>
 public DCSPackRecipe(UMAPackRecipe umaPackRecipe, string recipeName = "", string pRecipeType = "Standard", List <WardrobeSettings> wardrobeSetToSave = null)
 {
     //Debug.Log("DCSPackRecipe from umaPackRecipe");
     packedRecipeType = pRecipeType;
     name             = recipeName != "" ? recipeName : umaPackRecipe.race + "PackRecipe";//- if its coming from the recipe editor the we wont want to change a name
     race             = umaPackRecipe.race;
     dna             = umaPackRecipe.packedDna;
     characterColors = new List <PackedOverlayColorDataV3>(umaPackRecipe.fColors);
     //if this is coming from the Recipe Editor then it will need wardrobe settings- but it cant send them- however they will be in the activeWardrobeSet field
     if (wardrobeSetToSave != null)
     {
         wardrobeSet = wardrobeSetToSave;
     }
 }
示例#5
0
 public void Initialize()
 {
     umaPackRecipe = new UMAPackRecipe();
     if(!slotLibrary){
         slotLibrary = GameObject.Find("SlotLibrary").GetComponent("SlotLibrary") as SlotLibrary;
     }
     if(!raceLibrary){
         raceLibrary = GameObject.Find("RaceLibrary").GetComponent("RaceLibrary") as RaceLibrary;
     }
     if(!overlayLibrary){
         overlayLibrary = GameObject.Find("OverlayLibrary").GetComponent("OverlayLibrary") as OverlayLibrary;
     }
     if(!umaData){
         umaData = gameObject.GetComponent("UMAData") as UMAData;
     }
 }
示例#6
0
        public static void UnpackRecipe(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
        {
            switch (umaPackRecipe.version)
            {
            case 3:
                UnpackRecipeVersion3(umaRecipe, umaPackRecipe, context);
                break;

            case 2:
                UnpackRecipeVersion2(umaRecipe, umaPackRecipe, context);
                break;

            case 1:
            default:
                if (UnpackRecipeVersion1(umaRecipe, umaPackRecipe, context))
                {
                    umaRecipe.MergeMatchingOverlays();
                }
                break;
            }
        }
示例#7
0
 public void SetOverlayColorData(OverlayColorData overlayColorData)
 {
     overlayColorData.name = name;
     if (UMAPackRecipe.ArrayHasData(colors))
     {
         int channelCount = colors.Length / 8;
         overlayColorData.channelMask         = new Color[channelCount];
         overlayColorData.channelAdditiveMask = new Color[channelCount];
         int colorIndex = 0;
         for (int channel = 0; channel < channelCount; channel++)
         {
             overlayColorData.channelMask[channel].r         = colors[colorIndex++] / 255f;
             overlayColorData.channelMask[channel].g         = colors[colorIndex++] / 255f;
             overlayColorData.channelMask[channel].b         = colors[colorIndex++] / 255f;
             overlayColorData.channelMask[channel].a         = colors[colorIndex++] / 255f;
             overlayColorData.channelAdditiveMask[channel].r = colors[colorIndex++] / 255f;
             overlayColorData.channelAdditiveMask[channel].g = colors[colorIndex++] / 255f;
             overlayColorData.channelAdditiveMask[channel].b = colors[colorIndex++] / 255f;
             overlayColorData.channelAdditiveMask[channel].a = colors[colorIndex++] / 255f;
         }
     }
 }
示例#8
0
 public PackedOverlayColorDataV3(OverlayColorData colorData)
 {
     name = colorData.name;
     if (UMAPackRecipe.ArrayHasData(colorData.channelMask))
     {
         int channelCount = colorData.channelMask.Length;
         colors = new short[channelCount * 8];
         int colorIndex = 0;
         for (int channel = 0; channel < channelCount; channel++)
         {
             Color maskColor = colorData.channelMask[channel];
             colors[colorIndex++] = (short)Mathf.FloorToInt(maskColor.r * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(maskColor.g * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(maskColor.b * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(maskColor.a * 255f);
             Color additiveMaskColor = colorData.channelAdditiveMask[channel];
             colors[colorIndex++] = (short)Mathf.FloorToInt(additiveMaskColor.r * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(additiveMaskColor.g * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(additiveMaskColor.b * 255f);
             colors[colorIndex++] = (short)Mathf.FloorToInt(additiveMaskColor.a * 255f);
         }
     }
 }
示例#9
0
        public static void UnpackRecipeVersion2(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
        {
            umaRecipe.slotDataList = new SlotData[umaPackRecipe.slotsV2.Length];
            umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

            umaRecipe.ClearDna();
            List <UMADnaBase> packedDna = UnPackDNA(umaPackRecipe.packedDna);

            foreach (UMADnaBase umd in packedDna)
            {
                umaRecipe.AddDna(umd);
            }

            OverlayColorData[] colorData;
            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.fColors))
            {
                colorData = new OverlayColorData[umaPackRecipe.fColors.Length];
                for (int i = 0; i < colorData.Length; i++)
                {
                    colorData[i] = new OverlayColorData();
                    umaPackRecipe.fColors[i].SetOverlayColorData(colorData[i]);
                }
            }
            else if (UMAPackRecipe.ArrayHasData(umaPackRecipe.colors))
            {
                colorData = new OverlayColorData[umaPackRecipe.colors.Length];
                for (int i = 0; i < colorData.Length; i++)
                {
                    colorData[i] = new OverlayColorData();
                    umaPackRecipe.colors[i].SetOverlayColorData(colorData[i]);
                }
            }
            else
            {
                colorData = new OverlayColorData[0];
            }

            umaRecipe.sharedColors = new OverlayColorData[umaPackRecipe.sharedColorCount];
            for (int i = 0; i < umaRecipe.sharedColors.Length; i++)
            {
                umaRecipe.sharedColors[i] = colorData[i];
            }

            for (int i = 0; i < umaPackRecipe.slotsV2.Length; i++)
            {
                PackedSlotDataV2 packedSlot = umaPackRecipe.slotsV2[i];
                if (UMAPackRecipe.SlotIsValid(packedSlot))
                {
                    var tempSlotData = context.InstantiateSlot(packedSlot.id);
                    tempSlotData.overlayScale = packedSlot.scale * 0.01f;
                    umaRecipe.slotDataList[i] = tempSlotData;

                    if (packedSlot.copyIdx == -1)
                    {
                        for (int i2 = 0; i2 < packedSlot.overlays.Length; i2++)
                        {
                            PackedOverlayDataV2 packedOverlay = packedSlot.overlays[i2];
                            OverlayData         overlayData   = context.InstantiateOverlay(packedOverlay.id);
                            overlayData.rect = new Rect(packedOverlay.rect[0],
                                                        packedOverlay.rect[1],
                                                        packedOverlay.rect[2],
                                                        packedOverlay.rect[3]);
                            if (packedOverlay.colorIdx < umaPackRecipe.sharedColorCount)
                            {
                                overlayData.colorData = umaRecipe.sharedColors[packedOverlay.colorIdx];
                            }
                            else
                            {
                                overlayData.colorData      = colorData[packedOverlay.colorIdx].Duplicate();
                                overlayData.colorData.name = OverlayColorData.UNSHARED;
                            }
                            if (UMAPackRecipe.MaterialIsValid(overlayData.asset.material))
                            {
                                overlayData.EnsureChannels(overlayData.asset.material.channels.Length);
                            }
                            tempSlotData.AddOverlay(overlayData);
                        }
                    }
                    else
                    {
                        tempSlotData.SetOverlayList(umaRecipe.slotDataList[packedSlot.copyIdx].GetOverlayList());
                    }
                }
            }
        }
示例#10
0
 /// <summary>
 /// Serialize the packed recipe.
 /// </summary>
 /// <param name="packedRecipe">Packed recipe.</param>
 /// <param name="context">Context.</param>
 public abstract void PackedSave(UMAPackRecipe packedRecipe, UMAContext context);
示例#11
0
        public static bool UnpackRecipeVersion1(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
        {
            if (!UMAPackRecipe.ArrayHasData(umaPackRecipe.packedSlotDataList))
            {
                return(false);
            }

            umaRecipe.slotDataList = new SlotData[umaPackRecipe.packedSlotDataList.Length];

            umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

            umaRecipe.ClearDna();
            for (int dna = 0; dna < umaPackRecipe.packedDna.Count; dna++)
            {
                Type dnaType = UMADna.GetType(umaPackRecipe.packedDna[dna].dnaType);
                umaRecipe.AddDna(UMADna.LoadInstance(dnaType, umaPackRecipe.packedDna[dna].packedDna));
            }

            for (int i = 0; i < umaPackRecipe.packedSlotDataList.Length; i++)
            {
                if (UMAPackRecipe.SlotIsValid(umaPackRecipe.packedSlotDataList[i]))
                {
                    var tempSlotData = context.InstantiateSlot(umaPackRecipe.packedSlotDataList[i].slotID);
                    tempSlotData.overlayScale = umaPackRecipe.packedSlotDataList[i].overlayScale * 0.01f;
                    umaRecipe.slotDataList[i] = tempSlotData;

                    if (umaPackRecipe.packedSlotDataList[i].copyOverlayIndex == -1)
                    {
                        for (int overlay = 0; overlay < umaPackRecipe.packedSlotDataList[i].OverlayDataList.Length; overlay++)
                        {
                            Color tempColor;
                            Rect  tempRect;

                            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList))
                            {
                                tempColor = new Color(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[0] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[1] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[2] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[3] / 255.0f);
                            }
                            else
                            {
                                tempColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
                            }

                            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList))
                            {
                                Rect originalRect = context.InstantiateOverlay(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].overlayID).rect;
                                tempRect = new Rect(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[0], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[1], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[2], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[3]);

                                Vector2 aspectRatio = new Vector2(tempRect.width / originalRect.width, tempRect.height / originalRect.height);

                                tempRect = new Rect(tempRect.x / aspectRatio.x, tempRect.y / aspectRatio.y, tempRect.width / aspectRatio.x, tempRect.height / aspectRatio.y);
                            }
                            else
                            {
                                tempRect = new Rect(0, 0, 0, 0);
                            }

                            tempSlotData.AddOverlay(context.InstantiateOverlay(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].overlayID));
                            tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).colorData.color = tempColor;
                            tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).rect            = tempRect;

                            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelMaskList))
                            {
                                for (int channelAdjust = 0; channelAdjust < umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelMaskList.Length; channelAdjust++)
                                {
                                    packedOverlayData tempData = umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay];
                                    tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).SetColor(channelAdjust, new Color32((byte)tempData.channelMaskList[channelAdjust][0],
                                                                                                                               (byte)tempData.channelMaskList[channelAdjust][1],
                                                                                                                               (byte)tempData.channelMaskList[channelAdjust][2],
                                                                                                                               (byte)tempData.channelMaskList[channelAdjust][3]));
                                }
                            }

                            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelAdditiveMaskList))
                            {
                                for (int channelAdjust = 0; channelAdjust < umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelAdditiveMaskList.Length; channelAdjust++)
                                {
                                    packedOverlayData tempData = umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay];
                                    tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).SetAdditive(channelAdjust, new Color32((byte)tempData.channelAdditiveMaskList[channelAdjust][0],
                                                                                                                                  (byte)tempData.channelAdditiveMaskList[channelAdjust][1],
                                                                                                                                  (byte)tempData.channelAdditiveMaskList[channelAdjust][2],
                                                                                                                                  (byte)tempData.channelAdditiveMaskList[channelAdjust][3]));
                                }
                            }
                        }
                    }
                    else
                    {
                        tempSlotData.SetOverlayList(umaRecipe.slotDataList[umaPackRecipe.packedSlotDataList[i].copyOverlayIndex].GetOverlayList());
                    }
                }
            }
            return(true);
        }
示例#12
0
        /*
         * public static UMAPackRecipe PackRecipeV2(UMA.UMAData.UMARecipe umaRecipe)
         * {
         * UMAPackRecipe umaPackRecipe = new UMAPackRecipe();
         * umaPackRecipe.version = 2;
         *
         * int slotCount = umaRecipe.slotDataList.Length;
         * umaPackRecipe.slotsV2 = new PackedSlotDataV2[slotCount];
         * if (UMAPackRecipe.RaceIsValid(umaRecipe.raceData))
         * {
         *      umaPackRecipe.race = umaRecipe.raceData.raceName;
         * }
         *
         * umaPackRecipe.packedDna = GetPackedDNA(umaRecipe);
         *
         * umaPackRecipe.sharedColorCount = 0;
         * if (UMAPackRecipe.ArrayHasData(umaRecipe.sharedColors))
         *      umaPackRecipe.sharedColorCount = umaRecipe.sharedColors.Length;
         * List<OverlayColorData> colorEntries = new List<OverlayColorData>(umaPackRecipe.sharedColorCount);
         * List<PackedOverlayColorDataV3> packedColorEntries = new List<PackedOverlayColorDataV3>(umaPackRecipe.sharedColorCount);
         * for (int i = 0; i < umaPackRecipe.sharedColorCount; i++)
         * {
         *      colorEntries.Add(umaRecipe.sharedColors[i]);
         *      packedColorEntries.Add(new PackedOverlayColorDataV3(umaRecipe.sharedColors[i]));
         * }
         *
         * for (int i = 0; i < slotCount; i++)
         * {
         *      if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i]) && !umaRecipe.slotDataList[i].dontSerialize)
         *      {
         *              PackedSlotDataV2 tempPackedSlotData = new PackedSlotDataV2();
         *              umaPackRecipe.slotsV2[i] = tempPackedSlotData;
         *
         *              tempPackedSlotData.id = umaRecipe.slotDataList[i].asset.slotName;
         *              tempPackedSlotData.scale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);
         *
         *              bool copiedOverlays = false;
         *              for (int i2 = 0; i2 < i; i2++)
         *              {
         *                      if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i2]) && UMAPackRecipe.SlotIsValid(umaPackRecipe.slotsV2[i2]))
         *                      {
         *                              if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
         *                              {
         *                                      tempPackedSlotData.copyIdx = i2;
         *                                      copiedOverlays = true;
         *                                      break;
         *                              }
         *                      }
         *              }
         *              if (copiedOverlays) continue;
         *
         *              tempPackedSlotData.overlays = new PackedOverlayDataV2[umaRecipe.slotDataList[i].OverlayCount];
         *
         *              for (int overlayIdx = 0; overlayIdx < tempPackedSlotData.overlays.Length; overlayIdx++)
         *              {
         *                      PackedOverlayDataV2 tempPackedOverlay = new PackedOverlayDataV2();
         *
         *                      OverlayData overlayData = umaRecipe.slotDataList[i].GetOverlay(overlayIdx);
         *                      tempPackedOverlay.id = overlayData.overlayName;
         *                      tempPackedOverlay.rect = new int[4];
         *                      tempPackedOverlay.rect[0] = Mathf.FloorToInt(overlayData.rect.x);
         *                      tempPackedOverlay.rect[1] = Mathf.FloorToInt(overlayData.rect.y);
         *                      tempPackedOverlay.rect[2] = Mathf.FloorToInt(overlayData.rect.width);
         *                      tempPackedOverlay.rect[3] = Mathf.FloorToInt(overlayData.rect.height);
         *
         *                      OverlayColorData colorData = overlayData.colorData;
         *                      int colorIndex = -1;
         *                      int cIndex = 0;
         *                      foreach (OverlayColorData cData in colorEntries)
         *                      {
         *                              if (cData.name != null && cData.name.Equals(colorData.name) && cData.Equals(colorData))
         *                              {
         *                                      colorIndex = cIndex;
         *                                      break;
         *                              }
         *                              cIndex++;
         *                      }
         *
         *                      if (colorIndex < 0)
         *                      {
         *                              PackedOverlayColorDataV3 newColorEntry = new PackedOverlayColorDataV3(colorData);
         *                              packedColorEntries.Add(newColorEntry);
         *                              colorIndex = colorEntries.Count;
         *                              colorEntries.Add(colorData);
         *
         *                      }
         *
         *                      tempPackedOverlay.colorIdx = colorIndex;
         *
         *                      tempPackedSlotData.overlays[overlayIdx] = tempPackedOverlay;
         *              }
         *      }
         * }
         *
         * umaPackRecipe.fColors = packedColorEntries.ToArray();
         * return umaPackRecipe;
         * }
         */

        public static UMAPackRecipe PackRecipeV3(UMA.UMAData.UMARecipe umaRecipe)
        {
            UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

            umaPackRecipe.version = 3;

            int slotCount = umaRecipe.slotDataList.Length;

            umaPackRecipe.slotsV3 = new PackedSlotDataV3[slotCount];
            if (UMAPackRecipe.RaceIsValid(umaRecipe.raceData))
            {
                umaPackRecipe.race = umaRecipe.raceData.raceName;
            }

            umaPackRecipe.packedDna = GetPackedDNA(umaRecipe);

            umaPackRecipe.sharedColorCount = 0;
            if (UMAPackRecipe.ArrayHasData(umaRecipe.sharedColors))
            {
                umaPackRecipe.sharedColorCount = umaRecipe.sharedColors.Length;
            }
            List <OverlayColorData>         colorEntries       = new List <OverlayColorData>(umaPackRecipe.sharedColorCount);
            List <PackedOverlayColorDataV3> packedColorEntries = new List <PackedOverlayColorDataV3>(umaPackRecipe.sharedColorCount);

            for (int i = 0; i < umaPackRecipe.sharedColorCount; i++)
            {
                colorEntries.Add(umaRecipe.sharedColors[i]);
                packedColorEntries.Add(new PackedOverlayColorDataV3(umaRecipe.sharedColors[i]));
            }

            for (int i = 0; i < slotCount; i++)
            {
                if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i]) && !umaRecipe.slotDataList[i].dontSerialize)
                {
                    PackedSlotDataV3 tempPackedSlotData = new PackedSlotDataV3();
                    umaPackRecipe.slotsV3[i] = tempPackedSlotData;

                    tempPackedSlotData.id    = umaRecipe.slotDataList[i].asset.slotName;
                    tempPackedSlotData.scale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);

                    bool copiedOverlays = false;
                    for (int i2 = 0; i2 < i; i2++)
                    {
                        if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i2]) && UMAPackRecipe.SlotIsValid(umaPackRecipe.slotsV3[i2]))
                        {
                            if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                            {
                                tempPackedSlotData.copyIdx = i2;
                                copiedOverlays             = true;
                                break;
                            }
                        }
                    }
                    if (copiedOverlays)
                    {
                        continue;
                    }

                    tempPackedSlotData.overlays = new PackedOverlayDataV3[umaRecipe.slotDataList[i].OverlayCount];

                    for (int overlayIdx = 0; overlayIdx < tempPackedSlotData.overlays.Length; overlayIdx++)
                    {
                        PackedOverlayDataV3 tempPackedOverlay = new PackedOverlayDataV3();

                        OverlayData overlayData = umaRecipe.slotDataList[i].GetOverlay(overlayIdx);
                        tempPackedOverlay.id      = overlayData.overlayName;
                        tempPackedOverlay.rect    = new int[4];
                        tempPackedOverlay.rect[0] = Mathf.FloorToInt(overlayData.rect.x);
                        tempPackedOverlay.rect[1] = Mathf.FloorToInt(overlayData.rect.y);
                        tempPackedOverlay.rect[2] = Mathf.FloorToInt(overlayData.rect.width);
                        tempPackedOverlay.rect[3] = Mathf.FloorToInt(overlayData.rect.height);

                                                #if (UNITY_STANDALONE || UNITY_IOS || UNITY_ANDROID || UNITY_PS4 || UNITY_XBOXONE) && !UNITY_2017_3_OR_NEWER //supported platforms for procedural materials
                        if (overlayData.isProcedural && (overlayData.proceduralData != null))
                        {
                            tempPackedOverlay.data = new PackedOverlaySubstanceData[overlayData.proceduralData.Length];
                            for (int dataIdx = 0; dataIdx < overlayData.proceduralData.Length; dataIdx++)
                            {
                                tempPackedOverlay.data[dataIdx] = new PackedOverlaySubstanceData(overlayData.proceduralData[dataIdx]);
                            }
                        }
                        #endif

                        OverlayColorData colorData = overlayData.colorData;
                        int colorIndex             = -1;
                        int cIndex = 0;
                        foreach (OverlayColorData cData in colorEntries)
                        {
                            if (cData.name != null && cData.name.Equals(colorData.name) && cData.Equals(colorData))
                            {
                                colorIndex = cIndex;
                                break;
                            }
                            cIndex++;
                        }

                        if (colorIndex < 0)
                        {
                            PackedOverlayColorDataV3 newColorEntry = new PackedOverlayColorDataV3(colorData);
                            packedColorEntries.Add(newColorEntry);
                            colorIndex = colorEntries.Count;
                            colorEntries.Add(colorData);
                        }

                        tempPackedOverlay.colorIdx = colorIndex;

                        tempPackedSlotData.overlays[overlayIdx] = tempPackedOverlay;
                    }
                }
            }

            umaPackRecipe.fColors = packedColorEntries.ToArray();
            return(umaPackRecipe);
        }
示例#13
0
 public virtual void LoadFromMemoryStream()
 {
     //	Debug.Log ("LoadFromMemoryStream");
     umaPackRecipe = JsonMapper.ToObject <UMAPackRecipe>(streamedUMA);
     UnpackRecipe();
 }
示例#14
0
    public static UMAPackRecipe PackRecipe(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

        //var umaPackRecipe = new Packed
        umaPackRecipe.packedSlotDataList = new packedSlotData[umaRecipe.slotDataList.Length];
        umaPackRecipe.race = umaRecipe.raceData.raceName;

        umaPackRecipe.packedDna.Clear();

        foreach (var dna in umaRecipe.GetAllDna())
        {
            UMAPackedDna packedDna = new UMAPackedDna();
            packedDna.dnaType   = dna.GetType().Name;
            packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
            umaPackRecipe.packedDna.Add(packedDna);
        }

        for (int i = 0; i < umaRecipe.slotDataList.Length; i++)
        {
            if (umaRecipe.slotDataList[i] != null)
            {
                if (umaRecipe.slotDataList[i].listID != -1 && umaPackRecipe.packedSlotDataList[i] == null)
                {
                    packedSlotData tempPackedSlotData;

                    tempPackedSlotData = new packedSlotData();

                    tempPackedSlotData.slotID          = umaRecipe.slotDataList[i].slotName;
                    tempPackedSlotData.overlayScale    = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);
                    tempPackedSlotData.OverlayDataList = new packedOverlayData[umaRecipe.slotDataList[i].OverlayCount];

                    for (int overlayID = 0; overlayID < tempPackedSlotData.OverlayDataList.Length; overlayID++)
                    {
                        tempPackedSlotData.OverlayDataList[overlayID]           = new packedOverlayData();
                        tempPackedSlotData.OverlayDataList[overlayID].overlayID = umaRecipe.slotDataList[i].GetOverlay(overlayID).overlayName;

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).color != new Color(1.0f, 1.0f, 1.0f, 1.0f))
                        {
                            //Color32 instead of Color?
                            tempPackedSlotData.OverlayDataList[overlayID].colorList    = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[0] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.r * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[1] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.g * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[2] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.b * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[3] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.a * 255.0f);
                        }

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).rect != new Rect(0, 0, 0, 0))
                        {
                            //Might need float in next version
                            tempPackedSlotData.OverlayDataList[overlayID].rectList    = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[0] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.x;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[1] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.y;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[2] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.width;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[3] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.height;
                        }

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask != null)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList = new int[umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask.Length][];

                            for (int channelAdjust = 0; channelAdjust < umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask.Length; channelAdjust++)
                            {
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust]    = new int[4];
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][0] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].r;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][1] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].g;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][2] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].b;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][3] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].a;
                            }
                        }
                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask != null)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList = new int[umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask.Length][];
                            for (int channelAdjust = 0; channelAdjust < umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask.Length; channelAdjust++)
                            {
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust]    = new int[4];
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][0] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].r;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][1] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].g;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][2] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].b;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][3] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].a;
                            }
                        }
                    }

                    umaPackRecipe.packedSlotDataList[i] = tempPackedSlotData;

                    //Shared overlays wont generate duplicated data
                    for (int i2 = i + 1; i2 < umaRecipe.slotDataList.Length; i2++)
                    {
                        if (umaRecipe.slotDataList[i2] != null)
                        {
                            if (umaPackRecipe.packedSlotDataList[i2] == null)
                            {
                                if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                                {
                                    tempPackedSlotData                  = new packedSlotData();
                                    tempPackedSlotData.slotID           = umaRecipe.slotDataList[i2].slotName;
                                    tempPackedSlotData.copyOverlayIndex = i;
                                    //umaPackRecipe.packedSlotDataList[i2] = tempPackedSlotData;
                                }
                            }
                        }
                    }
                }
            }
        }
        return(umaPackRecipe);
    }
示例#15
0
    public static void UnpackRecipeVersion2(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
    {
        umaRecipe.slotDataList        = new SlotData[umaPackRecipe.slotsV2.Length];
        umaRecipe.additionalSlotCount = 0;
        umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

        umaRecipe.ClearDna();
        for (int dna = 0; dna < umaPackRecipe.packedDna.Count; dna++)
        {
            Type dnaType = UMADna.GetType(umaPackRecipe.packedDna[dna].dnaType);
            umaRecipe.AddDna(UMADna.LoadInstance(dnaType, umaPackRecipe.packedDna[dna].packedDna));
        }

        OverlayColorData[] colorData;
        if ((umaPackRecipe.fColors != null) && (umaPackRecipe.fColors.Length > 0))
        {
            colorData = new OverlayColorData[umaPackRecipe.fColors.Length];
            for (int i = 0; i < colorData.Length; i++)
            {
                colorData[i] = new OverlayColorData();
                umaPackRecipe.fColors[i].SetOverlayColorData(colorData[i]);
            }
        }
        else if ((umaPackRecipe.colors != null) && (umaPackRecipe.colors.Length > 0))
        {
            colorData = new OverlayColorData[umaPackRecipe.colors.Length];
            for (int i = 0; i < colorData.Length; i++)
            {
                colorData[i] = new OverlayColorData();
                umaPackRecipe.colors[i].SetOverlayColorData(colorData[i]);
            }
        }
        else
        {
            colorData = new OverlayColorData[0];
        }

        umaRecipe.sharedColors = new OverlayColorData[umaPackRecipe.sharedColorCount];
        for (int i = 0; i < umaRecipe.sharedColors.Length; i++)
        {
            umaRecipe.sharedColors[i] = colorData[i];
        }

        for (int i = 0; i < umaPackRecipe.slotsV2.Length; i++)
        {
            PackedSlotDataV2 packedSlot = umaPackRecipe.slotsV2[i];
            if (packedSlot != null && packedSlot.id != null)
            {
                var tempSlotData = context.InstantiateSlot(packedSlot.id);
                tempSlotData.overlayScale = packedSlot.scale * 0.01f;
                umaRecipe.slotDataList[i] = tempSlotData;

                if (packedSlot.copyIdx == -1)
                {
                    for (int i2 = 0; i2 < packedSlot.overlays.Length; i2++)
                    {
                        PackedOverlayDataV2 packedOverlay = packedSlot.overlays[i2];
                        OverlayData         overlayData   = context.InstantiateOverlay(packedOverlay.id);
                        overlayData.rect = new Rect(packedOverlay.rect[0],
                                                    packedOverlay.rect[1],
                                                    packedOverlay.rect[2],
                                                    packedOverlay.rect[3]);
                        if (packedOverlay.colorIdx < umaPackRecipe.sharedColorCount)
                        {
                            overlayData.colorData = umaRecipe.sharedColors[packedOverlay.colorIdx];
                        }
                        else
                        {
                            overlayData.colorData = colorData[packedOverlay.colorIdx];
                        }
                        overlayData.EnsureChannels(overlayData.asset.material.channels.Length);
                        tempSlotData.AddOverlay(overlayData);
                    }
                }
                else
                {
                    tempSlotData.SetOverlayList(umaRecipe.slotDataList[packedSlot.copyIdx].GetOverlayList());
                }
            }
        }
    }
示例#16
0
 public static UMAData.UMARecipe UnpackRecipeVersion3(UMAPackRecipe umaPackRecipe, UMAContext context)
 {
     UMAData.UMARecipe umaRecipe = new UMAData.UMARecipe();
     UnpackRecipeVersion3(umaRecipe, umaPackRecipe, context);
     return(umaRecipe);
 }
示例#17
0
/*
 *      public static UMAPackRecipe PackRecipeV1(UMA.UMAData.UMARecipe umaRecipe)
 *      {
 *              UMAPackRecipe umaPackRecipe = new UMAPackRecipe();
 *
 *              //var umaPackRecipe = new Packed
 *              int slotCount = umaRecipe.slotDataList.Length - umaRecipe.AdditionalSlots;
 *              umaPackRecipe.packedSlotDataList = new packedSlotData[slotCount];
 *              umaPackRecipe.race = umaRecipe.raceData.raceName;
 *
 *              foreach (var dna in umaRecipe.GetAllDna())
 *              {
 *                      UMAPackedDna packedDna = new UMAPackedDna();
 *                      packedDna.dnaType = dna.GetType().Name;
 *                      packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
 *                      umaPackRecipe.packedDna.Add(packedDna);
 *              }
 *
 *              for (int i = 0; i < slotCount; i++)
 *              {
 *                      if (umaRecipe.slotDataList[i] != null)
 *                      {
 *                              packedSlotData tempPackedSlotData = new packedSlotData();
 *                              umaPackRecipe.packedSlotDataList[i] = tempPackedSlotData;
 *
 *                              tempPackedSlotData.slotID = umaRecipe.slotDataList[i].asset.slotName;
 *                              tempPackedSlotData.overlayScale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);
 *
 *                              bool copiedOverlays = false;
 *                              for (int i2 = 0; i2 < i; i2++)
 *                              {
 *                                      if (umaRecipe.slotDataList[i2] != null && umaPackRecipe.packedSlotDataList[i2] != null)
 *                                      {
 *                                              if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
 *                                              {
 *                                                      tempPackedSlotData.copyOverlayIndex = i2;
 *                                                      copiedOverlays = true;
 *                                                      break;
 *                                              }
 *                                      }
 *                              }
 *                              if( copiedOverlays ) continue;
 *
 *                              tempPackedSlotData.OverlayDataList = new packedOverlayData[umaRecipe.slotDataList[i].OverlayCount];
 *
 *                              for (int overlayID = 0; overlayID < tempPackedSlotData.OverlayDataList.Length; overlayID++)
 *                              {
 *                                      tempPackedSlotData.OverlayDataList[overlayID] = new packedOverlayData();
 *                                      tempPackedSlotData.OverlayDataList[overlayID].overlayID = umaRecipe.slotDataList[i].GetOverlay(overlayID).asset.overlayName;
 *                                      OverlayColorData colorData = umaRecipe.slotDataList[i].GetOverlay(overlayID).colorData;
 *                                      if (colorData.color != Color.white)
 *                                      {
 *                                              Color32 color = umaRecipe.slotDataList[i].GetOverlay(overlayID).colorData.color;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].colorList = new int[4];
 *                                              tempPackedSlotData.OverlayDataList[overlayID].colorList[0] = color.r;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].colorList[1] = color.g;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].colorList[2] = color.b;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].colorList[3] = color.a;
 *                                      }
 *
 *                                      if (umaRecipe.slotDataList[i].GetOverlay(overlayID).rect != new Rect(0, 0, 0, 0))
 *                                      {
 *                                              //Might need float in next version
 *                                              tempPackedSlotData.OverlayDataList[overlayID].rectList = new int[4];
 *                                              tempPackedSlotData.OverlayDataList[overlayID].rectList[0] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.x;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].rectList[1] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.y;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].rectList[2] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.width;
 *                                              tempPackedSlotData.OverlayDataList[overlayID].rectList[3] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.height;
 *                                      }
 *
 *                                      if (colorData.channelMask != null && colorData.channelMask.Length > 0)
 *                                      {
 *                                              tempPackedSlotData.OverlayDataList[overlayID].channelMaskList = new int[colorData.channelMask.Length][];
 *
 *                                              for (int channelAdjust = 0; channelAdjust < colorData.channelMask.Length; channelAdjust++)
 *                                              {
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust] = new int[4];
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][0] = colorData.channelMask[channelAdjust].r;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][1] = colorData.channelMask[channelAdjust].g;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][2] = colorData.channelMask[channelAdjust].b;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][3] = colorData.channelMask[channelAdjust].a;
 *                                              }
 *
 *                                      }
 *                                      if (colorData.channelAdditiveMask != null)
 *                                      {
 *                                              tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList = new int[colorData.channelAdditiveMask.Length][];
 *                                              for (int channelAdjust = 0; channelAdjust < colorData.channelAdditiveMask.Length; channelAdjust++)
 *                                              {
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust] = new int[4];
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][0] = colorData.channelAdditiveMask[channelAdjust].r;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][1] = colorData.channelAdditiveMask[channelAdjust].g;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][2] = colorData.channelAdditiveMask[channelAdjust].b;
 *                                                      tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][3] = colorData.channelAdditiveMask[channelAdjust].a;
 *                                              }
 *
 *                                      }
 *                              }
 *                      }
 *              }
 *              return umaPackRecipe;
 *      }
 */

    public static UMAPackRecipe PackRecipeV2(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

        umaPackRecipe.version = 2;

        int slotCount = umaRecipe.slotDataList.Length - umaRecipe.additionalSlotCount;

        umaPackRecipe.slotsV2 = new PackedSlotDataV2[slotCount];
        if (umaRecipe.raceData != null)
        {
            umaPackRecipe.race = umaRecipe.raceData.raceName;
        }

        foreach (var dna in umaRecipe.GetAllDna())
        {
            UMAPackedDna packedDna = new UMAPackedDna();
            packedDna.dnaType   = dna.GetType().Name;
            packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
            umaPackRecipe.packedDna.Add(packedDna);
        }

        umaPackRecipe.sharedColorCount = 0;
        if (umaRecipe.sharedColors != null)
        {
            umaPackRecipe.sharedColorCount = umaRecipe.sharedColors.Length;
        }
        List <OverlayColorData>         colorEntries       = new List <OverlayColorData>(umaPackRecipe.sharedColorCount);
        List <PackedOverlayColorDataV3> packedColorEntries = new List <PackedOverlayColorDataV3>(umaPackRecipe.sharedColorCount);

        for (int i = 0; i < umaPackRecipe.sharedColorCount; i++)
        {
            colorEntries.Add(umaRecipe.sharedColors[i]);
            packedColorEntries.Add(new PackedOverlayColorDataV3(umaRecipe.sharedColors[i]));
        }

        for (int i = 0; i < slotCount; i++)
        {
            if (umaRecipe.slotDataList[i] != null)
            {
                PackedSlotDataV2 tempPackedSlotData = new PackedSlotDataV2();
                umaPackRecipe.slotsV2[i] = tempPackedSlotData;

                tempPackedSlotData.id    = umaRecipe.slotDataList[i].asset.slotName;
                tempPackedSlotData.scale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);

                bool copiedOverlays = false;
                for (int i2 = 0; i2 < i; i2++)
                {
                    if (umaRecipe.slotDataList[i2] != null && umaPackRecipe.slotsV2[i2] != null)
                    {
                        if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                        {
                            tempPackedSlotData.copyIdx = i2;
                            copiedOverlays             = true;
                            break;
                        }
                    }
                }
                if (copiedOverlays)
                {
                    continue;
                }

                tempPackedSlotData.overlays = new PackedOverlayDataV2[umaRecipe.slotDataList[i].OverlayCount];

                for (int overlayIdx = 0; overlayIdx < tempPackedSlotData.overlays.Length; overlayIdx++)
                {
                    PackedOverlayDataV2 tempPackedOverlay = new PackedOverlayDataV2();

                    OverlayData overlayData = umaRecipe.slotDataList[i].GetOverlay(overlayIdx);
                    tempPackedOverlay.id      = overlayData.asset.overlayName;
                    tempPackedOverlay.rect    = new int[4];
                    tempPackedOverlay.rect[0] = Mathf.FloorToInt(overlayData.rect.x);
                    tempPackedOverlay.rect[1] = Mathf.FloorToInt(overlayData.rect.y);
                    tempPackedOverlay.rect[2] = Mathf.FloorToInt(overlayData.rect.width);
                    tempPackedOverlay.rect[3] = Mathf.FloorToInt(overlayData.rect.height);

                    OverlayColorData colorData = overlayData.colorData;
                    // Could not use IndexOf to find color, since operator == overriden in OverlayColorData
                    int colorIndex = -1;
                    for (int col = 0; col < colorEntries.Count; col++)
                    {
                        if (colorEntries[col].GetHashCode() == colorData.GetHashCode())
                        {
                            colorIndex = col;
                        }
                    }


                    if (colorIndex < 0)
                    {
                        PackedOverlayColorDataV3 newColorEntry = new PackedOverlayColorDataV3(colorData);
                        packedColorEntries.Add(newColorEntry);
                        colorIndex = colorEntries.Count;
                        colorEntries.Add(colorData);
                    }
                    tempPackedOverlay.colorIdx = colorIndex;

                    tempPackedSlotData.overlays[overlayIdx] = tempPackedOverlay;
                }
            }
        }

        umaPackRecipe.fColors = packedColorEntries.ToArray();
        return(umaPackRecipe);
    }
示例#18
0
 /// <summary>
 /// Serialize the packed recipe.
 /// </summary>
 /// <param name="packedRecipe">Packed recipe.</param>
 /// <param name="context">Context.</param>
 public abstract void PackedSave(UMAPackRecipe packedRecipe, UMAContext context);
示例#19
0
    public static void UnpackRecipeVersion2(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
    {
        umaRecipe.slotDataList = new SlotData[umaPackRecipe.slotsV2.Length];
        umaRecipe.additionalSlotCount = 0;
        umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

        umaRecipe.ClearDna();
        for (int dna = 0; dna < umaPackRecipe.packedDna.Count; dna++)
        {
            Type dnaType = UMADna.GetType(umaPackRecipe.packedDna[dna].dnaType);
            umaRecipe.AddDna(UMADna.LoadInstance(dnaType, umaPackRecipe.packedDna[dna].packedDna));
        }

        OverlayColorData[] colorData;
        if ((umaPackRecipe.fColors != null) && (umaPackRecipe.fColors.Length > 0))
        {
            colorData = new OverlayColorData[umaPackRecipe.fColors.Length];
            for (int i = 0; i < colorData.Length; i++)
            {
                colorData[i] = new OverlayColorData();
                umaPackRecipe.fColors[i].SetOverlayColorData(colorData[i]);
            }
        }
        else if ((umaPackRecipe.colors != null) && (umaPackRecipe.colors.Length > 0))
        {
            colorData = new OverlayColorData[umaPackRecipe.colors.Length];
            for (int i = 0; i < colorData.Length; i++)
            {
                colorData[i] = new OverlayColorData();
                umaPackRecipe.colors[i].SetOverlayColorData(colorData[i]);
            }
        }
        else {
            colorData = new OverlayColorData[0];
        }

        umaRecipe.sharedColors = new OverlayColorData[umaPackRecipe.sharedColorCount];
        for (int i = 0; i < umaRecipe.sharedColors.Length; i++)
        {
            umaRecipe.sharedColors[i] = colorData[i];
        }

        for (int i = 0; i < umaPackRecipe.slotsV2.Length; i++)
        {
            PackedSlotDataV2 packedSlot = umaPackRecipe.slotsV2[i];
            if (packedSlot != null && packedSlot.id != null)
            {
                var tempSlotData = context.InstantiateSlot(packedSlot.id);
                tempSlotData.overlayScale = packedSlot.scale * 0.01f;
                umaRecipe.slotDataList[i] = tempSlotData;

                if (packedSlot.copyIdx == -1)
                {
                    for (int i2 = 0; i2 < packedSlot.overlays.Length; i2++)
                    {
                        PackedOverlayDataV2 packedOverlay = packedSlot.overlays[i2];
                        OverlayData overlayData = context.InstantiateOverlay(packedOverlay.id);
                        overlayData.rect = new Rect(packedOverlay.rect[0],
                                                    packedOverlay.rect[1],
                                                    packedOverlay.rect[2],
                                                    packedOverlay.rect[3]);
                        if (packedOverlay.colorIdx < umaPackRecipe.sharedColorCount)
                        {
                            overlayData.colorData = umaRecipe.sharedColors[packedOverlay.colorIdx];
                        }
                        else
                        {
                            overlayData.colorData = colorData[packedOverlay.colorIdx];
                        }
                        overlayData.EnsureChannels(overlayData.asset.material.channels.Length);
                        tempSlotData.AddOverlay(overlayData);
                    }
                }
                else
                {
                    tempSlotData.SetOverlayList(umaRecipe.slotDataList[packedSlot.copyIdx].GetOverlayList());
                }
            }
        }
    }
示例#20
0
    public static bool UnpackRecipeVersion1(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
    {
        if (umaPackRecipe.packedSlotDataList == null)
            return false;

        umaRecipe.slotDataList = new SlotData[umaPackRecipe.packedSlotDataList.Length];
        umaRecipe.additionalSlotCount = 0;
        umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

        umaRecipe.ClearDna();
        for (int dna = 0; dna < umaPackRecipe.packedDna.Count; dna++)
        {
            Type dnaType = UMADna.GetType(umaPackRecipe.packedDna[dna].dnaType);
            umaRecipe.AddDna(UMADna.LoadInstance(dnaType, umaPackRecipe.packedDna[dna].packedDna));
        }

        for (int i = 0; i < umaPackRecipe.packedSlotDataList.Length; i++)
        {
            if (umaPackRecipe.packedSlotDataList[i] != null && umaPackRecipe.packedSlotDataList[i].slotID != null)
            {
                var tempSlotData = context.InstantiateSlot(umaPackRecipe.packedSlotDataList[i].slotID);
                tempSlotData.overlayScale = umaPackRecipe.packedSlotDataList[i].overlayScale * 0.01f;
                umaRecipe.slotDataList[i] = tempSlotData;

                if (umaPackRecipe.packedSlotDataList[i].copyOverlayIndex == -1)
                {

                    for (int overlay = 0; overlay < umaPackRecipe.packedSlotDataList[i].OverlayDataList.Length; overlay++)
                    {
                        Color tempColor;
                        Rect tempRect;

                        if (umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList != null)
                        {
                            tempColor = new Color(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[0] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[1] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[2] / 255.0f, umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].colorList[3] / 255.0f);
                        }
                        else
                        {
                            tempColor = new Color(1.0f, 1.0f, 1.0f, 1.0f);
                        }

                        if (umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList != null)
                        {
                            Rect originalRect = context.InstantiateOverlay(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].overlayID).rect;
                            tempRect = new Rect(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[0], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[1], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[2], umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].rectList[3]);

                            Vector2 aspectRatio = new Vector2(tempRect.width/originalRect.width,tempRect.height/originalRect.height);

                            tempRect = new Rect(tempRect.x/aspectRatio.x,tempRect.y/aspectRatio.y,tempRect.width/aspectRatio.x,tempRect.height/aspectRatio.y);

                        }
                        else
                        {
                            tempRect = new Rect(0, 0, 0, 0);
                        }

                        tempSlotData.AddOverlay(context.InstantiateOverlay(umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].overlayID));
                        tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).colorData.color = tempColor;
                        tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).rect = tempRect;

                        if (umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelMaskList != null)
                        {
                            for (int channelAdjust = 0; channelAdjust < umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelMaskList.Length; channelAdjust++)
                            {
                                packedOverlayData tempData = umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay];
                                tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).SetColor(channelAdjust, new Color32((byte)tempData.channelMaskList[channelAdjust][0],
                                                                                                                           (byte)tempData.channelMaskList[channelAdjust][1],
                                                                                                                           (byte)tempData.channelMaskList[channelAdjust][2],
                                                                                                                           (byte)tempData.channelMaskList[channelAdjust][3]));
                            }
                        }

                        if (umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelAdditiveMaskList != null)
                        {
                            for (int channelAdjust = 0; channelAdjust < umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay].channelAdditiveMaskList.Length; channelAdjust++)
                            {
                                packedOverlayData tempData = umaPackRecipe.packedSlotDataList[i].OverlayDataList[overlay];
                                tempSlotData.GetOverlay(tempSlotData.OverlayCount - 1).SetAdditive(channelAdjust, new Color32((byte)tempData.channelAdditiveMaskList[channelAdjust][0],
                                                                                                                              (byte)tempData.channelAdditiveMaskList[channelAdjust][1],
                                                                                                                              (byte)tempData.channelAdditiveMaskList[channelAdjust][2],
                                                                                                                              (byte)tempData.channelAdditiveMaskList[channelAdjust][3]));
                            }
                        }

                    }
                }
                else
                {
                    tempSlotData.SetOverlayList(umaRecipe.slotDataList[umaPackRecipe.packedSlotDataList[i].copyOverlayIndex].GetOverlayList());
                }
            }
        }
        return true;
    }
示例#21
0
    /*
    public static UMAPackRecipe PackRecipeV1(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

        //var umaPackRecipe = new Packed
        int slotCount = umaRecipe.slotDataList.Length - umaRecipe.AdditionalSlots;
        umaPackRecipe.packedSlotDataList = new packedSlotData[slotCount];
        umaPackRecipe.race = umaRecipe.raceData.raceName;

        foreach (var dna in umaRecipe.GetAllDna())
        {
            UMAPackedDna packedDna = new UMAPackedDna();
            packedDna.dnaType = dna.GetType().Name;
            packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
            umaPackRecipe.packedDna.Add(packedDna);
        }

        for (int i = 0; i < slotCount; i++)
        {
            if (umaRecipe.slotDataList[i] != null)
            {
                packedSlotData tempPackedSlotData = new packedSlotData();
                umaPackRecipe.packedSlotDataList[i] = tempPackedSlotData;

                tempPackedSlotData.slotID = umaRecipe.slotDataList[i].asset.slotName;
                tempPackedSlotData.overlayScale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);

                bool copiedOverlays = false;
                for (int i2 = 0; i2 < i; i2++)
                {
                    if (umaRecipe.slotDataList[i2] != null && umaPackRecipe.packedSlotDataList[i2] != null)
                    {
                        if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                        {
                            tempPackedSlotData.copyOverlayIndex = i2;
                            copiedOverlays = true;
                            break;
                        }
                    }
                }
                if( copiedOverlays ) continue;

                tempPackedSlotData.OverlayDataList = new packedOverlayData[umaRecipe.slotDataList[i].OverlayCount];

                for (int overlayID = 0; overlayID < tempPackedSlotData.OverlayDataList.Length; overlayID++)
                {
                    tempPackedSlotData.OverlayDataList[overlayID] = new packedOverlayData();
                    tempPackedSlotData.OverlayDataList[overlayID].overlayID = umaRecipe.slotDataList[i].GetOverlay(overlayID).asset.overlayName;
                    OverlayColorData colorData = umaRecipe.slotDataList[i].GetOverlay(overlayID).colorData;
                    if (colorData.color != Color.white)
                    {
                        Color32 color = umaRecipe.slotDataList[i].GetOverlay(overlayID).colorData.color;
                        tempPackedSlotData.OverlayDataList[overlayID].colorList = new int[4];
                        tempPackedSlotData.OverlayDataList[overlayID].colorList[0] = color.r;
                        tempPackedSlotData.OverlayDataList[overlayID].colorList[1] = color.g;
                        tempPackedSlotData.OverlayDataList[overlayID].colorList[2] = color.b;
                        tempPackedSlotData.OverlayDataList[overlayID].colorList[3] = color.a;
                    }

                    if (umaRecipe.slotDataList[i].GetOverlay(overlayID).rect != new Rect(0, 0, 0, 0))
                    {
                        //Might need float in next version
                        tempPackedSlotData.OverlayDataList[overlayID].rectList = new int[4];
                        tempPackedSlotData.OverlayDataList[overlayID].rectList[0] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.x;
                        tempPackedSlotData.OverlayDataList[overlayID].rectList[1] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.y;
                        tempPackedSlotData.OverlayDataList[overlayID].rectList[2] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.width;
                        tempPackedSlotData.OverlayDataList[overlayID].rectList[3] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.height;
                    }

                    if (colorData.channelMask != null && colorData.channelMask.Length > 0)
                    {
                        tempPackedSlotData.OverlayDataList[overlayID].channelMaskList = new int[colorData.channelMask.Length][];

                        for (int channelAdjust = 0; channelAdjust < colorData.channelMask.Length; channelAdjust++)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust] = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][0] = colorData.channelMask[channelAdjust].r;
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][1] = colorData.channelMask[channelAdjust].g;
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][2] = colorData.channelMask[channelAdjust].b;
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][3] = colorData.channelMask[channelAdjust].a;
                        }

                    }
                    if (colorData.channelAdditiveMask != null)
                    {
                        tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList = new int[colorData.channelAdditiveMask.Length][];
                        for (int channelAdjust = 0; channelAdjust < colorData.channelAdditiveMask.Length; channelAdjust++)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust] = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][0] = colorData.channelAdditiveMask[channelAdjust].r;
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][1] = colorData.channelAdditiveMask[channelAdjust].g;
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][2] = colorData.channelAdditiveMask[channelAdjust].b;
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][3] = colorData.channelAdditiveMask[channelAdjust].a;
                        }

                    }
                }
            }
        }
        return umaPackRecipe;
    }
    */
    public static UMAPackRecipe PackRecipeV2(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();
        umaPackRecipe.version = 2;

        int slotCount = umaRecipe.slotDataList.Length - umaRecipe.additionalSlotCount;
        umaPackRecipe.slotsV2 = new PackedSlotDataV2[slotCount];
        if (umaRecipe.raceData != null)
        {
            umaPackRecipe.race = umaRecipe.raceData.raceName;
        }

        foreach (var dna in umaRecipe.GetAllDna())
        {
            UMAPackedDna packedDna = new UMAPackedDna();
            packedDna.dnaType = dna.GetType().Name;
            packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
            umaPackRecipe.packedDna.Add(packedDna);
        }

        umaPackRecipe.sharedColorCount = 0;
        if (umaRecipe.sharedColors != null)
            umaPackRecipe.sharedColorCount = umaRecipe.sharedColors.Length;
        List<OverlayColorData> colorEntries = new List<OverlayColorData>(umaPackRecipe.sharedColorCount);
        List<PackedOverlayColorDataV3> packedColorEntries = new List<PackedOverlayColorDataV3>(umaPackRecipe.sharedColorCount);
        for (int i = 0; i < umaPackRecipe.sharedColorCount; i++)
        {
            colorEntries.Add(umaRecipe.sharedColors[i]);
            packedColorEntries.Add(new PackedOverlayColorDataV3(umaRecipe.sharedColors[i]));
        }

        for (int i = 0; i < slotCount; i++)
        {
            if (umaRecipe.slotDataList[i] != null)
            {
                PackedSlotDataV2 tempPackedSlotData = new PackedSlotDataV2();
                umaPackRecipe.slotsV2[i] = tempPackedSlotData;

                tempPackedSlotData.id = umaRecipe.slotDataList[i].asset.slotName;
                tempPackedSlotData.scale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);

                bool copiedOverlays = false;
                for (int i2 = 0; i2 < i; i2++)
                {
                    if (umaRecipe.slotDataList[i2] != null && umaPackRecipe.slotsV2[i2] != null)
                    {
                        if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                        {
                            tempPackedSlotData.copyIdx = i2;
                            copiedOverlays = true;
                            break;
                        }
                    }
                }
                if( copiedOverlays ) continue;

                tempPackedSlotData.overlays = new PackedOverlayDataV2[umaRecipe.slotDataList[i].OverlayCount];

                for (int overlayIdx = 0; overlayIdx < tempPackedSlotData.overlays.Length; overlayIdx++)
                {
                    PackedOverlayDataV2 tempPackedOverlay = new PackedOverlayDataV2();

                    OverlayData overlayData = umaRecipe.slotDataList[i].GetOverlay(overlayIdx);
                    tempPackedOverlay.id = overlayData.asset.overlayName;
                    tempPackedOverlay.rect = new int[4];
                    tempPackedOverlay.rect[0] = Mathf.FloorToInt(overlayData.rect.x);
                    tempPackedOverlay.rect[1] = Mathf.FloorToInt(overlayData.rect.y);
                    tempPackedOverlay.rect[2] = Mathf.FloorToInt(overlayData.rect.width);
                    tempPackedOverlay.rect[3] = Mathf.FloorToInt(overlayData.rect.height);

                    OverlayColorData colorData = overlayData.colorData;
                    int colorIndex = colorEntries.IndexOf(colorData);
                    if (colorIndex < 0)
                    {
                        PackedOverlayColorDataV3 newColorEntry = new PackedOverlayColorDataV3(colorData);
                        packedColorEntries.Add(newColorEntry);
                        colorIndex = colorEntries.Count;
                        colorEntries.Add(colorData);
                    }
                    tempPackedOverlay.colorIdx = colorIndex;

                    tempPackedSlotData.overlays[overlayIdx] = tempPackedOverlay;
                }
            }
        }

        umaPackRecipe.fColors = packedColorEntries.ToArray();
        return umaPackRecipe;
    }
示例#22
0
        public static void UnpackRecipeVersion3(UMA.UMAData.UMARecipe umaRecipe, UMAPackRecipe umaPackRecipe, UMAContext context)
        {
            umaRecipe.slotDataList = new SlotData[umaPackRecipe.slotsV3.Length];
            umaRecipe.SetRace(context.GetRace(umaPackRecipe.race));

            umaRecipe.ClearDna();
            List <UMADnaBase> packedDna = UnPackDNA(umaPackRecipe.packedDna);

            foreach (UMADnaBase umd in packedDna)
            {
                umaRecipe.AddDna(umd);
            }

            OverlayColorData[] colorData;
            if (UMAPackRecipe.ArrayHasData(umaPackRecipe.fColors))
            {
                colorData = new OverlayColorData[umaPackRecipe.fColors.Length];
                for (int i = 0; i < colorData.Length; i++)
                {
                    colorData[i] = new OverlayColorData();
                    umaPackRecipe.fColors[i].SetOverlayColorData(colorData[i]);
                }
            }
            else if (UMAPackRecipe.ArrayHasData(umaPackRecipe.colors))
            {
                colorData = new OverlayColorData[umaPackRecipe.colors.Length];
                for (int i = 0; i < colorData.Length; i++)
                {
                    colorData[i] = new OverlayColorData();
                    umaPackRecipe.colors[i].SetOverlayColorData(colorData[i]);
                }
            }
            else
            {
                colorData = new OverlayColorData[0];
            }

            umaRecipe.sharedColors = new OverlayColorData[umaPackRecipe.sharedColorCount];
            for (int i = 0; i < umaRecipe.sharedColors.Length; i++)
            {
                umaRecipe.sharedColors[i] = colorData[i];
            }

            for (int i = 0; i < umaPackRecipe.slotsV3.Length; i++)
            {
                PackedSlotDataV3 packedSlot = umaPackRecipe.slotsV3[i];
                if (UMAPackRecipe.SlotIsValid(packedSlot))
                {
                    var tempSlotData = context.InstantiateSlot(packedSlot.id);
                    tempSlotData.overlayScale = packedSlot.scale * 0.01f;
                    umaRecipe.slotDataList[i] = tempSlotData;

                    if (packedSlot.copyIdx == -1)
                    {
                        for (int i2 = 0; i2 < packedSlot.overlays.Length; i2++)
                        {
                            PackedOverlayDataV3 packedOverlay = packedSlot.overlays[i2];
                            OverlayData         overlayData   = context.InstantiateOverlay(packedOverlay.id);
                            overlayData.rect = new Rect(
                                packedOverlay.rect[0],
                                packedOverlay.rect[1],
                                packedOverlay.rect[2],
                                packedOverlay.rect[3]);

                            if (packedOverlay.colorIdx < umaPackRecipe.sharedColorCount)
                            {
                                overlayData.colorData = umaRecipe.sharedColors[packedOverlay.colorIdx];
                            }
                            else
                            {
                                overlayData.colorData      = colorData[packedOverlay.colorIdx].Duplicate();
                                overlayData.colorData.name = OverlayColorData.UNSHARED;
                            }

                            if (UMAPackRecipe.MaterialIsValid(overlayData.asset.material))
                            {
                                overlayData.EnsureChannels(overlayData.asset.material.channels.Length);
                            }

                                                        #if (UNITY_STANDALONE || UNITY_IOS || UNITY_ANDROID || UNITY_PS4 || UNITY_XBOXONE) && !UNITY_2017_3_OR_NEWER //supported platforms for procedural materials
                            if (packedOverlay.data == null)
                            {
                                overlayData.proceduralData = new OverlayData.OverlayProceduralData[0];
                            }
                            else
                            {
                                overlayData.proceduralData = new OverlayData.OverlayProceduralData[packedOverlay.data.Length];

                                for (int dataIdx = 0; dataIdx < packedOverlay.data.Length; dataIdx++)
                                {
                                    OverlayData.OverlayProceduralData proceduralData = new OverlayData.OverlayProceduralData();
                                    packedOverlay.data[dataIdx].SetOverlayProceduralData(proceduralData);
                                    overlayData.proceduralData[dataIdx] = proceduralData;
                                }
                            }
                            #endif

                            tempSlotData.AddOverlay(overlayData);
                        }
                    }
                    else
                    {
                        tempSlotData.SetOverlayList(umaRecipe.slotDataList[packedSlot.copyIdx].GetOverlayList());
                    }
                }
            }
        }
示例#23
0
 public virtual void LoadFromMemoryStream()
 {
     umaPackRecipe = JsonMapper.ToObject<UMAPackRecipe>(streamedUMA);
     UnpackRecipe();
 }
示例#24
0
    public static UMAPackRecipe PackRecipeV2(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

        umaPackRecipe.version = 2;

        int slotCount = umaRecipe.slotDataList.Length;

        umaPackRecipe.slotsV2 = new PackedSlotDataV2[slotCount];
        if (UMAPackRecipe.RaceIsValid(umaRecipe.raceData))
        {
            umaPackRecipe.race = umaRecipe.raceData.raceName;
        }

        /*foreach (var dna in umaRecipe.GetAllDna())
         *      {
         *              UMAPackedDna packedDna = new UMAPackedDna();
         *              //DynamicUMADna:: needs the typeHash as this is randomly generated by the DynamicDnaConverter
         *              packedDna.dnaTypeHash = dna.DNATypeHash;
         *              packedDna.dnaType = dna.GetType().Name;
         *              //DynamicUMADna:: test here for DynamicUMADna here because UMADna_generated doesn't have it
         *              if (packedDna.dnaType == "DynamicUMADna")
         *              {
         *                      packedDna.packedDna = UMA.DynamicUMADna.SaveInstance(dna as UMA.DynamicUMADna);
         *              }
         *              else
         *                      packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
         *              umaPackRecipe.packedDna.Add(packedDna);
         *      }*/
        umaPackRecipe.packedDna = GetPackedDNA(umaRecipe);


        umaPackRecipe.sharedColorCount = 0;
        if (UMAPackRecipe.ArrayHasData(umaRecipe.sharedColors))
        {
            umaPackRecipe.sharedColorCount = umaRecipe.sharedColors.Length;
        }
        List <OverlayColorData>         colorEntries       = new List <OverlayColorData>(umaPackRecipe.sharedColorCount);
        List <PackedOverlayColorDataV3> packedColorEntries = new List <PackedOverlayColorDataV3>(umaPackRecipe.sharedColorCount);

        for (int i = 0; i < umaPackRecipe.sharedColorCount; i++)
        {
            colorEntries.Add(umaRecipe.sharedColors[i]);
            packedColorEntries.Add(new PackedOverlayColorDataV3(umaRecipe.sharedColors[i]));
        }

        for (int i = 0; i < slotCount; i++)
        {
            if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i]) && !umaRecipe.slotDataList[i].dontSerialize)
            {
                PackedSlotDataV2 tempPackedSlotData = new PackedSlotDataV2();
                umaPackRecipe.slotsV2[i] = tempPackedSlotData;

                tempPackedSlotData.id    = umaRecipe.slotDataList[i].asset.slotName;
                tempPackedSlotData.scale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);

                bool copiedOverlays = false;
                for (int i2 = 0; i2 < i; i2++)
                {
                    if (UMAPackRecipe.SlotIsValid(umaRecipe.slotDataList[i2]) && UMAPackRecipe.SlotIsValid(umaPackRecipe.slotsV2[i2]))
                    {
                        if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                        {
                            tempPackedSlotData.copyIdx = i2;
                            copiedOverlays             = true;
                            break;
                        }
                    }
                }
                if (copiedOverlays)
                {
                    continue;
                }

                tempPackedSlotData.overlays = new PackedOverlayDataV2[umaRecipe.slotDataList[i].OverlayCount];

                for (int overlayIdx = 0; overlayIdx < tempPackedSlotData.overlays.Length; overlayIdx++)
                {
                    PackedOverlayDataV2 tempPackedOverlay = new PackedOverlayDataV2();

                    OverlayData overlayData = umaRecipe.slotDataList[i].GetOverlay(overlayIdx);
                    tempPackedOverlay.id      = overlayData.asset.overlayName;
                    tempPackedOverlay.rect    = new int[4];
                    tempPackedOverlay.rect[0] = Mathf.FloorToInt(overlayData.rect.x);
                    tempPackedOverlay.rect[1] = Mathf.FloorToInt(overlayData.rect.y);
                    tempPackedOverlay.rect[2] = Mathf.FloorToInt(overlayData.rect.width);
                    tempPackedOverlay.rect[3] = Mathf.FloorToInt(overlayData.rect.height);

                    OverlayColorData colorData = overlayData.colorData;
                    int colorIndex             = -1;
                    int cIndex = 0;
                    foreach (OverlayColorData cData in colorEntries)
                    {
                        if (cData.name != null && cData.name.Equals(colorData.name) && cData.Equals(colorData))
                        {
                            colorIndex = cIndex;
                            break;
                        }
                        cIndex++;
                    }

                    if (colorIndex < 0)
                    {
                        PackedOverlayColorDataV3 newColorEntry = new PackedOverlayColorDataV3(colorData);
                        packedColorEntries.Add(newColorEntry);
                        colorIndex = colorEntries.Count;
                        colorEntries.Add(colorData);
                    }

                    tempPackedOverlay.colorIdx = colorIndex;

                    tempPackedSlotData.overlays[overlayIdx] = tempPackedOverlay;
                }
            }
        }

        umaPackRecipe.fColors = packedColorEntries.ToArray();
        return(umaPackRecipe);
    }
    public static UMAPackRecipe PackRecipe(UMA.UMAData.UMARecipe umaRecipe)
    {
        UMAPackRecipe umaPackRecipe = new UMAPackRecipe();

        //var umaPackRecipe = new Packed
        umaPackRecipe.packedSlotDataList = new packedSlotData[umaRecipe.slotDataList.Length];
        umaPackRecipe.race = umaRecipe.raceData.raceName;

        umaPackRecipe.packedDna.Clear();

        foreach (var dna in umaRecipe.umaDna.Values)
        {
            UMAPackedDna packedDna = new UMAPackedDna();
            packedDna.dnaType = dna.GetType().Name;
            packedDna.packedDna = UMA.UMADna.SaveInstance(dna);
            umaPackRecipe.packedDna.Add(packedDna);
        }

        for (int i = 0; i < umaRecipe.slotDataList.Length; i++)
        {
            if (umaRecipe.slotDataList[i] != null)
            {
                if (umaRecipe.slotDataList[i].listID != -1 && umaPackRecipe.packedSlotDataList[i] == null)
                {
                    packedSlotData tempPackedSlotData;

                    tempPackedSlotData = new packedSlotData();

                    tempPackedSlotData.slotID = umaRecipe.slotDataList[i].slotName;
                    tempPackedSlotData.overlayScale = Mathf.FloorToInt(umaRecipe.slotDataList[i].overlayScale * 100);
                    tempPackedSlotData.OverlayDataList = new packedOverlayData[umaRecipe.slotDataList[i].OverlayCount];

                    for (int overlayID = 0; overlayID < tempPackedSlotData.OverlayDataList.Length; overlayID++)
                    {
                        tempPackedSlotData.OverlayDataList[overlayID] = new packedOverlayData();
                        tempPackedSlotData.OverlayDataList[overlayID].overlayID = umaRecipe.slotDataList[i].GetOverlay(overlayID).overlayName;

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).color != new Color(1.0f, 1.0f, 1.0f, 1.0f))
                        {
                            //Color32 instead of Color?
                            tempPackedSlotData.OverlayDataList[overlayID].colorList = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[0] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.r * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[1] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.g * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[2] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.b * 255.0f);
                            tempPackedSlotData.OverlayDataList[overlayID].colorList[3] = Mathf.FloorToInt(umaRecipe.slotDataList[i].GetOverlay(overlayID).color.a * 255.0f);
                        }

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).rect != new Rect(0, 0, 0, 0))
                        {
                            //Might need float in next version
                            tempPackedSlotData.OverlayDataList[overlayID].rectList = new int[4];
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[0] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.x;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[1] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.y;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[2] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.width;
                            tempPackedSlotData.OverlayDataList[overlayID].rectList[3] = (int)umaRecipe.slotDataList[i].GetOverlay(overlayID).rect.height;
                        }

                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask != null)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelMaskList = new int[umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask.Length][];

                            for (int channelAdjust = 0; channelAdjust < umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask.Length; channelAdjust++)
                            {
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust] = new int[4];
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][0] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].r;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][1] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].g;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][2] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].b;
                                tempPackedSlotData.OverlayDataList[overlayID].channelMaskList[channelAdjust][3] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelMask[channelAdjust].a;
                            }

                        }
                        if (umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask != null)
                        {
                            tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList = new int[umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask.Length][];
                            for (int channelAdjust = 0; channelAdjust < umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask.Length; channelAdjust++)
                            {
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust] = new int[4];
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][0] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].r;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][1] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].g;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][2] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].b;
                                tempPackedSlotData.OverlayDataList[overlayID].channelAdditiveMaskList[channelAdjust][3] = umaRecipe.slotDataList[i].GetOverlay(overlayID).channelAdditiveMask[channelAdjust].a;
                            }

                        }
                    }

                    umaPackRecipe.packedSlotDataList[i] = tempPackedSlotData;

                    //Shared overlays wont generate duplicated data
                    for (int i2 = i + 1; i2 < umaRecipe.slotDataList.Length; i2++)
                    {
                        if (umaRecipe.slotDataList[i2] != null)
                        {
                            if (umaPackRecipe.packedSlotDataList[i2] == null)
                            {
                                if (umaRecipe.slotDataList[i].GetOverlayList() == umaRecipe.slotDataList[i2].GetOverlayList())
                                {
                                    tempPackedSlotData = new packedSlotData();
                                    tempPackedSlotData.slotID = umaRecipe.slotDataList[i2].slotName;
                                    tempPackedSlotData.copyOverlayIndex = i;
                                    //umaPackRecipe.packedSlotDataList[i2] = tempPackedSlotData;
                                }
                            }
                        }
                    }
                }
            }
        }
        return umaPackRecipe;
    }