public static ColorToVoxelMap GetColorToVoxelMapDefinition(ColorBasedModelDefinition model)
        {
            ColorToVoxelMap mapping      = ScriptableObject.CreateInstance <ColorToVoxelMap> ();
            List <Color32>  uniqueColors = new List <Color32> ();
            Color32         prevColor    = Misc.color32Transparent;

            for (int k = 0; k < model.colors.Length; k++)
            {
                Color32 color = model.colors [k];
                if (color.a == 0 || (color.r == prevColor.r && color.g == prevColor.g && color.b == prevColor.b && color.a == prevColor.a))
                {
                    continue;
                }
                if (!uniqueColors.Contains(color))
                {
                    uniqueColors.Add(color);
                }
            }
            int colorCount = uniqueColors.Count;

            mapping.colorMap = new ColorToVoxelMapEntry[colorCount];
            for (int k = 0; k < colorCount; k++)
            {
                mapping.colorMap [k].color = uniqueColors [k];
            }
            return(mapping);
        }
示例#2
0
        void GenerateColorMapAsset()
        {
            ColorBasedModelDefinition baseModel = QubicleBinaryToColorBasedModelDefinition();

            if (baseModel.colors == null)
            {
                return;
            }
            ColorToVoxelMap colorMap = VoxelPlayConverter.GetColorToVoxelMapDefinition(baseModel);

            if (!string.IsNullOrEmpty(baseModel.name))
            {
                colorMap.name = baseModel.name;
            }

            colorMap.name += " ColorMap";

            // Create a suitable file path
            string path = GetPathForNewAsset();

            AssetDatabase.CreateAsset(colorMap, path + "/" + GetFilenameForNewModel(colorMap.name) + ".asset");
            AssetDatabase.SaveAssets();
            EditorUtility.FocusProjectWindow();
            Selection.activeObject = colorMap;
            EditorGUIUtility.PingObject(colorMap);
        }
示例#3
0
        void OnGUI()
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.HelpBox("Import voxel models from other applications.", MessageType.Info);
            EditorGUILayout.EndHorizontal();
            EditorGUILayout.Separator();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("Format", GUILayout.Width(120));
            importFormat = (ImportFormat)EditorGUILayout.EnumPopup(importFormat);
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField("File name", GUILayout.Width(120));
            importFilename = EditorGUILayout.TextField(importFilename);
            if (GUILayout.Button("Open...", GUILayout.Width(80)))
            {
                importFilename = EditorUtility.OpenFilePanel("Select model File (*.qb)", "", "qb");
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(new GUIContent("Color-Voxel Map", "Optional color to voxel mapping."), GUILayout.Width(120));
            mapping = (ColorToVoxelMap)EditorGUILayout.ObjectField(mapping, typeof(ColorToVoxelMap), false);
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(new GUIContent("Ignore Offset", "Model can specify an offset for the center."), GUILayout.Width(120));
            importIgnoreOffset = EditorGUILayout.Toggle(importIgnoreOffset);
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.LabelField(new GUIContent("Scale", "Scale applied to the model."), GUILayout.Width(120));
            scale = EditorGUILayout.Vector3Field("", scale);
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.Separator();
            GUI.enabled = !string.IsNullOrEmpty(importFilename);
            EditorGUILayout.BeginHorizontal();
            if (GUILayout.Button("Generate ColorMap Asset"))
            {
                GenerateColorMapAsset();
                GUIUtility.ExitGUI();
            }
            if (GUILayout.Button("Generate Model Asset"))
            {
                GenerateModelAsset();
                GUIUtility.ExitGUI();
            }
            if (GUILayout.Button("Generate Prefab"))
            {
                GeneratePrefab();
                GUIUtility.ExitGUI();
            }
            GUI.enabled = false;
            EditorGUILayout.EndHorizontal();
        }
        public static ModelDefinition GetModelDefinition(VoxelDefinition voxelTemplate, ColorBasedModelDefinition model, bool ignoreOffset, ColorToVoxelMap colorMap = null)
        {
            ModelDefinition md = ScriptableObject.CreateInstance <ModelDefinition> ();

            md.sizeX = model.sizeX;
            md.sizeY = model.sizeY;
            md.sizeZ = model.sizeZ;
            if (!ignoreOffset)
            {
                md.offsetX = model.offsetX;
                md.offsetY = model.offsetY;
                md.offsetZ = model.offsetZ;
            }
            if (colorMap != null && voxelTemplate == null)
            {
                voxelTemplate = colorMap.defaultVoxelDefinition;
            }
            List <ModelBit> bits = new List <ModelBit> ();

            for (int y = 0; y < model.sizeY; y++)
            {
                int posy = y * model.sizeX * model.sizeZ;
                for (int z = 0; z < model.sizeZ; z++)
                {
                    int posz = z * model.sizeX;
                    for (int x = 0; x < model.sizeX; x++)
                    {
                        int index = posy + posz + x;
                        if (model.colors [index].a > 0)
                        {
                            ModelBit bit = new ModelBit();
                            bit.voxelIndex = index;
                            if (colorMap != null)
                            {
                                bit.voxelDefinition = colorMap.GetVoxelDefinition(model.colors [index], voxelTemplate);
                                bit.color           = Misc.color32White;
                            }
                            else
                            {
                                bit.voxelDefinition = voxelTemplate;
                                bit.color           = model.colors [index];
                            }
                            bits.Add(bit);
                        }
                    }
                }
            }
            md.bits = bits.ToArray();
            return(md);
        }