Esempio n. 1
0
        void PackVector4()
        {
            Vector4[] ar;

            if (SameSizeValue != null)
            {
                if (MeshSolutions.dataTypeFilter != null && SameSizeValue.GetType() != MeshSolutions.dataTypeFilter)
                {
                    return;
                }

                SameSizeValue.GenerateIfNull();

                ar = SameSizeValue.GetV4(Target);
            }
            else
            {
                ar = new Vector4[MeshSolutions.vcnt];

                for (int i = 0; i < MeshSolutions.vcnt; i++)
                {
                    ar[i] = new Vector4();
                }

                for (int i = 0; i < 4; i++)
                {
                    VertexDataValue v   = vals[i];
                    float[]         tmp = v.GetDataArray();

                    if (tmp != null)
                    {
                        for (int j = 0; j < MeshSolutions.vcnt; j++)
                        {
                            ar[j][i] = tmp[j];
                        }
                    }
                }
            }

            if (ar != null)
            {
                Target.Set(ar);
            }
        }
Esempio n. 2
0
        public virtual bool PEGI()
        {
            bool changed = false;

            (Target.Name() + ":").toggle(80, ref enabled);

            if (enabled)
            {
                List <VertexDataType> tps = MeshSolutions.GetTypesBySize(vals.Count);
                string[] nms = new string[tps.Count + 1];

                for (int i = 0; i < tps.Count; i++)
                {
                    nms[i] = tps[i].ToString();
                }

                nms[tps.Count] = "Other";

                int selected = tps.Count;

                if (SameSizeValue != null)
                {
                    for (int i = 0; i < tps.Count; i++)
                    {
                        if (tps[i] == SameSizeValue)
                        {
                            selected = i;
                            break;
                        }
                    }
                }

                changed |= pegi.select(ref selected, nms).nl();

                if (selected >= tps.Count)
                {
                    sameSizeDataIndex = -1;
                }
                else
                {
                    sameSizeDataIndex = tps[selected].myIndex;
                }

                string[] allDataNames = MeshSolutions.GetAllTypesNames();

                if (SameSizeValue == null)
                {
                    for (int i = 0; i < vals.Count; i++)
                    {
                        VertexDataValue v = vals[i];

                        changed |= Target.GetFieldName(i).select(40, ref v.typeIndex, allDataNames);

                        string[] typeFields = new string[v.VertDataType.chanelsNeed];

                        for (int j = 0; j < typeFields.Length; j++)
                        {
                            typeFields[j] = v.VertDataType.GetFieldName(j);
                        }



                        changed |= pegi.select(ref v.valueIndex, typeFields).nl();

                        v.valueIndex = v.valueIndex.ClampZeroTo(typeFields.Length);
                    }
                }
                "**************************************************".nl();
            }

            return(changed);
        }