コード例 #1
0
 private static void LoadData(string cubletName)
 {
     ModelImporter importer = new ModelImporter(pathToDataFiles + cubletName + @"\" + cubletName + ".obj");
     CubletRenderingData data = new CubletRenderingData();
     data.normalArray = importer.normalArray;
     data.texelArray = importer.texelArray;
     data.triangleArray = importer.triangleArray;
     data.vertexArray = importer.vertexArray;
     cubletDictionary.Add(cubletName, data);
 }
コード例 #2
0
        public void Load_TestObj_ValidNumberOfVertices()
        {
            var importer = new ModelImporter();
            var model = importer.Load(@"Models\obj\test.obj");
            int countVertices = 0;
            model.Traverse<GeometryModel3D>((geometryModel, transform) =>
                {
                    var mesh = (MeshGeometry3D)geometryModel.Geometry;
                    countVertices += mesh.Positions.Count;
                });

            Assert.AreEqual(17, countVertices);
        }
コード例 #3
0
ファイル: ModelScanner.cs プロジェクト: JeReT/AssetStoreTools
        private void ScanForAnimations()
        {
            List <string> pathsWithExtensions = ValidatorData.GetPathsWithExtensions(ValidatorData.MODEL_EXTENSIONS, null);

            foreach (string text in pathsWithExtensions)
            {
                List <ModelImporterClipAnimation> list = new List <ModelImporterClipAnimation>();
                ModelImporter modelImporter            = (ModelImporter)AssetImporter.GetAtPath(text);
                list.AddRange(modelImporter.clipAnimations);
                list.AddRange(modelImporter.defaultClipAnimations);
                HashSet <string> hashSet = new HashSet <string>();
                for (int i = 0; i < list.Count; i++)
                {
                    if (!hashSet.Add(list[i].name))
                    {
                        this.animationCheck.AddPath(text);
                        break;
                    }
                }
            }
        }
コード例 #4
0
    protected void OnPreprocessModel()
    {
        // Restrict this to the same folders as the standard asset post-processor.
        if (!ProjectAssetPostprocessor.IsIncludedFolder(assetPath))
        {
            return;
        }

        if (!assetPath.ToLower().Contains(SpriteAnimImporterPrefs.NameFilter.ToLower()))
        {
            return;
        }

        ModelImporter importer = (ModelImporter)assetImporter;

        importer.importMaterials = true;



        Debug.Log("SpriteAnimImporter: Asset path " + assetPath + " contained sprite animation marker " + SpriteAnimImporterPrefs.NameFilter.ToLower() + ". Beginning import pre-processing.");
    }
コード例 #5
0
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = (ModelImporter)assetImporter;

        // MATERIAL NAME
        //     ModelImporterMaterialName.BasedOnMaterialName
        //     ModelImporterMaterialName.BasedOnModelNameAndMaterialName
        //     ModelImporterMaterialName.BasedOnTextureName
        modelImporter.materialName = ModelImporterMaterialName.BasedOnMaterialName;

        // MATERIAL SEARCH
        //     ModelImporterMaterialSearch.Everywhere
        //     ModelImporterMaterialSearch.Local
        //     ModelImporterMaterialSearch.RecursiveUp
        modelImporter.materialSearch = ModelImporterMaterialSearch.Everywhere;

        if (assetPath.Contains("@") && modelImporter.animationType != ModelImporterAnimationType.Human)
        {
            modelImporter.animationType = ModelImporterAnimationType.Legacy;
        }
    }
コード例 #6
0
        /// <summary>
        /// set AnimationClip
        /// </summary>
        private void SetAnimationClips(ModelImporter importer, CustomModelImporterSettingValue customSettings)
        {
            var clips = importer.clipAnimations;

            if (clips == null)
            {
                return;
            }

            for (int i = 0; i < clips.Length; i++)
            {
                var clip = clips[i];

                if (customSettings.LoopTime.IsConfigurable)
                {
                    clip.loopTime = customSettings.LoopTime;
                }
            }

            importer.clipAnimations = clips;
        }
コード例 #7
0
        private void Log(string path, Transform trans, string hierarchy)
        {
            ////Debug.Log("Prefab:" + path + System.Environment.NewLine
            ////        + "GameObject " + hierarchy + System.Environment.NewLine
            ////        + "MeshCollider and scale " + trans.localScale + " (lossy " + trans.lossyScale + ")");

            // "Prefab\tGameObject\tLocal scale\tLossy scale\tMesh\tMesh Asset\tRead/write\tCheck"
            MeshCollider mc        = trans.GetComponent <MeshCollider>();
            Mesh         mesh      = mc.sharedMesh;
            string       assetPath = mesh ? AssetDatabase.GetAssetPath(mesh) : "-";

            ModelImporter meshImporter = mesh ? AssetImporter.GetAtPath(assetPath) as ModelImporter : null;

            this.csvLog.AppendLine(path + "\t"
                                   + hierarchy + "\t"
                                   + "(" + trans.localScale.x + "," + trans.localScale.y + "," + trans.localScale.z + ")\t"
                                   + "(" + trans.lossyScale.x + "," + trans.lossyScale.y + "," + trans.lossyScale.z + ")\t"
                                   + (mesh ? mesh.name : "[null]") + "\t"
                                   + (mesh ? AssetDatabase.GetAssetPath(mesh) : "-") + "\t"
                                   + (meshImporter ? meshImporter.isReadable.ToString() : "-") + "\t");
        }
コード例 #8
0
ファイル: TemplateLoaderTest.cs プロジェクト: Kozu-vr/VitDeck
        public void TestFbxReferenceModifier()
        {
            var replaceList = new Dictionary <string, string>();

            replaceList.Add("BOOTHID", "id");
            replaceList.Add("NAME", "name");
            AssetDatabase.CreateFolder("Assets", "TestTemplateLoad");
            Assert.That(TemplateLoader.Load("Sample_template", replaceList, "Assets/TestTemplateLoad"), Is.True);
            var modelImporter = ModelImporter.GetAtPath("Assets/TestTemplateLoad/id_name/Models/Sample_object.fbx");
            var map           = modelImporter.GetExternalObjectMap();

            foreach (var pair in map)
            {
                if (pair.Value is Material)
                {
                    var mat     = pair.Value as Material;
                    var matPath = AssetDatabase.GetAssetPath(mat.GetInstanceID());
                    Assert.That(matPath, Is.EqualTo("Assets/TestTemplateLoad/id_name/Materials/Sample Material.mat"));
                }
            }
        }
コード例 #9
0
ファイル: ResImprotPost.cs プロジェクト: howelllucas/Project
    public static void FormateFbx(ref ModelImporter model)
    {
        model.animationType   = ModelImporterAnimationType.None;
        model.importMaterials = false;
        model.importAnimation = false;

        model.meshCompression      = ModelImporterMeshCompression.High;
        model.importTangents       = ModelImporterTangents.None;
        model.isReadable           = false;
        model.optimizeMesh         = true;
        model.importBlendShapes    = false;
        model.weldVertices         = true;
        model.addCollider          = false;
        model.importVisibility     = false;
        model.importCameras        = false;
        model.importLights         = false;
        model.preserveHierarchy    = false;
        model.swapUVChannels       = false;
        model.animationCompression = ModelImporterAnimationCompression.Optimal;
        model.indexFormat          = ModelImporterIndexFormat.UInt16;
    }
コード例 #10
0
    static void Change2Generic()
    {
        Object _obj = Selection.activeObject;

        string[]         _temp  = Directory.GetFiles(AssetDatabase.GetAssetPath(_obj), "*.FBX", SearchOption.AllDirectories);
        HashSet <string> _paths = new HashSet <string>();

        foreach (var item in _temp)
        {
            _paths.Add(item);
        }
        foreach (var item in _paths)
        {
            ModelImporter _ai = ModelImporter.GetAtPath(item) as ModelImporter;
            _ai.animationType = ModelImporterAnimationType.Generic;
            _ai.SaveAndReimport();
        }
        AssetDatabase.SaveAssets();
        AssetDatabase.Refresh();
        Debug.Log("将该目录下的所有fbx改为generic 完成");
    }
コード例 #11
0
        private static void ApplyModelRule(ModelImporter modelImporter, ModelFolderRule rule)
        {
            if (rule == null)
            {
                return;
            }

            ModelFolderRule newRule = CustomImportRuleFactory.Create(modelImporter, rule);

            if (null == newRule)
            {
                return;
            }

            SerializedObject modelSerObj = new SerializedObject(modelImporter);

            SerializedObjectUtility.CopyInstanceToSerializedObject(modelSerObj.GetIterator(), newRule);
            modelSerObj.ApplyModifiedProperties();
            AssetDatabase.Refresh();
            newRule.DoCustomRule(modelImporter);
        }
コード例 #12
0
        public static void OnPostprocessModel(ModelImporter importer)
        {
            postprocessorUtils = postprocessorUtils ? postprocessorUtils : SoAssetPostprocessorUtils.GetSoAssetPostprocessorUtils();
            var guid = postprocessorUtils.Get(PostprocessorAssetType.Model, importer.assetPath);

            if (string.IsNullOrEmpty(guid))
            {
                return;
            }

            var path = AssetDatabase.GUIDToAssetPath(guid);
            var so   = AssetDatabase.LoadAssetAtPath <SoModelPostprocessor>(path);

            if (so == null)
            {
                so = SoAssetPostprocessor.GetDefault(PostprocessorAssetType.Model) as SoModelPostprocessor;
            }

            SetSettings(importer, so);
            Reimport(importer, so);
        }
コード例 #13
0
    // This method is called just before importing an FBX.
    void OnPreprocessModel()
    {
        Debug.Log("OnPreprocessModel assetPath:" + assetPath);
        ModelImporter mi = (ModelImporter)assetImporter;

        mi.globalScale = 1;

        if (!assetPath.Contains("/Characters/"))
        {
            return;
        }
        mi.animationCompression = ModelImporterAnimationCompression.Off;


        // we don't need Materials for Bones and  Animation.
        if (assetPath.Contains("/Models"))
        {
            return;
        }
        mi.importMaterials = false;
    }
コード例 #14
0
 public Model3D Display3d(string model)
 {
     try
     {
         ModelImporter import = new ModelImporter();
         device = import.Load(model);
         device.SetName("robot");
         // get real size of robot
         robot3DInfo.Sx = device.Bounds.SizeX;                 // mm to m
         robot3DInfo.Sy = device.Bounds.SizeY;
         robot3DInfo.Sz = device.Bounds.SizeZ;
         ScaledRobot(GlobalVariables.ROBOT_SCALED, GlobalVariables.ROBOT_SCALED, 0);
         contentlayer.Children.Add(device3D);
     }
     catch (Exception e)
     {
         // Handle exception in case can not file 3D model
         MessageBox.Show("Exception Error : " + e.StackTrace);
     }
     return(device);
 }
コード例 #15
0
    public static bool CheckFBXEmbeddedTextures(string fbxPath)/*fbxPath Example : @"Assets\TESTFBX\Demo_10.fbx" */
    {
        BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance;

        ModelImporter fbx        = AssetImporter.GetAtPath(fbxPath) as ModelImporter;
        var           fbx_editor = Editor.CreateEditor(fbx);

        var tabsProp = fbx_editor.GetType().GetProperty("tabs", flags);

        System.Array tabs = (System.Array)tabsProp.GetValue(fbx_editor);

        var modelImporterMaterialEditor = tabs.GetValue(3);
        var hasEmbeddedTexturesProp     = modelImporterMaterialEditor.GetType().GetField("m_HasEmbeddedTextures", flags);

        SerializedProperty hasEmbeddedTextures = hasEmbeddedTexturesProp.GetValue(modelImporterMaterialEditor) as SerializedProperty;
        bool result = hasEmbeddedTextures.boolValue;

        Editor.DestroyImmediate(fbx_editor, false);

        return(result);
    }
コード例 #16
0
    void OnPreprocessModel()
    {
        ModelImporter modelImporter = assetImporter as ModelImporter;

        // Model Settings
        modelImporter.importCameras = false;
        modelImporter.importLights  = false;

        // Rig settings
        modelImporter.animationType = ModelImporterAnimationType.Human;

        // Animatino Settings
        modelImporter.importAnimation = false;


        // Material
        if (!modelImporter.ExtractTextures(@"Assets/Textures"))
        {
            Debug.LogError("Failed to extract textures");
        }
    }
コード例 #17
0
    public void OnPreprocessModel(string importAssetPath, AssetImporter assetImporter)
    {
        ModelImporter templateImporter = GetTemplateAssetImporter(importAssetPath) as ModelImporter;

        if (templateImporter == null)
        {
            return;
        }

        // 如果模板被更改,那么更新全部资源
        if (Path.GetFileName(importAssetPath) == Path.GetFileName(templateImporter.assetPath))
        {
            ProcessAllModel(templateImporter);
            return;
        }

        ModelImporter targetImporter = assetImporter as ModelImporter;

        ImportCopyer.CopyModelImporter(targetImporter, templateImporter);
        Debug.Log($"[DefaultProcessor] 资源格式设置完毕 : {importAssetPath}");
    }
コード例 #18
0
            public static void ConfigureImportSettings(string filename, object customSettings = null)
            {
                if (customSettings == null)
                {
                    customSettings = new {
                        resampleCurves       = false,
                        animationType        = ModelImporterAnimationType.Legacy,
                        animationCompression = ModelImporterAnimationCompression.Off,
                        importConstraints    = true
                    };
                }

                ModelImporter modelImporter = AssetImporter.GetAtPath(filename) as ModelImporter;

                modelImporter.resampleCurves = (bool)customSettings.GetType().GetProperty("resampleCurves").GetValue(customSettings, null);
                AssetDatabase.ImportAsset(filename);
                modelImporter.animationType        = (ModelImporterAnimationType)customSettings.GetType().GetProperty("animationType").GetValue(customSettings, null);
                modelImporter.animationCompression = (ModelImporterAnimationCompression)customSettings.GetType().GetProperty("animationCompression").GetValue(customSettings, null);
                modelImporter.importConstraints    = (bool)customSettings.GetType().GetProperty("importConstraints").GetValue(customSettings, null);
                AssetDatabase.ImportAsset(filename);
            }
コード例 #19
0
    public void OnPreprocessModel()
    {
        Debug.Log(assetImporter.name);
        //#if !CUTANI
        //        Debug.Log("没有定义 CUTANI");
        //        return;
        //#endif
        //Bean.InitPublicExcelTables();

        if (!File.Exists(path))
        {
            Debug.Log("文件不存在  " + path);
            return;
        }

        ModelImporter _modelImporter = (ModelImporter)assetImporter;

        _modelImporter.animationType = ModelImporterAnimationType.Legacy;
        //_modelImporter.generateAnimations = ModelImporterGenerateAnimations.GenerateAnimations;



        string[] strs = File.ReadAllLines(path);
        Debug.Log(path + "  " + strs.Length);
        string sel = Selection.activeObject.name;

        if (sel == null || strs[0] != sel)
        {
            Debug.LogError("streamingAssetsPath/ani.txt 名字没有修改 :" + sel + ":  " + strs[0]);
            return;
        }

        ModelImporterClipAnimation[] _animations = new ModelImporterClipAnimation[strs.Length - 1];
        for (int i = 1; i < strs.Length; i++)
        {
            string[] aniStrs = strs[i].Split('|');
            _animations[i - 1] = SetClipAnimation(i.ToString(), int.Parse(aniStrs[0]), int.Parse(aniStrs[1]), i == 1);
        }
        _modelImporter.clipAnimations = _animations;
    }
コード例 #20
0
 	private void OnPreprocessModel()
 	{
 		ModelImporter modelImporter = assetImporter as ModelImporter;
 		if( modelImporter != null )
 		{
 			bool useImportSettings = EditorPrefs.GetBool( "ModelImportManager.UseImportSettings", false );
 			if( useImportSettings )
 			{
 				string presetName = EditorPrefs.GetString( "ModelImportManager.CurrentPreset", string.Empty );
  
 				string prefix = "ModelImportManager." + presetName;
  
 				// Meshes
 				modelImporter.globalScale = EditorPrefs.GetFloat( prefix + ".GlobalScale", 1.0f );
 				modelImporter.meshCompression = (ModelImporterMeshCompression)System.Enum.Parse( typeof(ModelImporterMeshCompression),
 												EditorPrefs.GetString( prefix + ".MeshCompression", "Off" ) );
 				modelImporter.optimizeMesh = EditorPrefs.GetBool( prefix + ".OptimizeMesh", false );
 				modelImporter.addCollider = EditorPrefs.GetBool( prefix + ".AddCollider", false );
 				modelImporter.swapUVChannels = EditorPrefs.GetBool( prefix + ".SwapUVChannels", false );
 				modelImporter.generateSecondaryUV = EditorPrefs.GetBool( prefix + ".GenerateSecondaryUV", false );
  
 				// Normals & Tangents
 				modelImporter.normalImportMode = (ModelImporterTangentSpaceMode)System.Enum.Parse( typeof(ModelImporterTangentSpaceMode),
 								EditorPrefs.GetString( prefix + ".NormalImportMode", "Import" ) );
 				modelImporter.tangentImportMode = (ModelImporterTangentSpaceMode)System.Enum.Parse( typeof(ModelImporterTangentSpaceMode),
 								EditorPrefs.GetString( prefix + ".TangentImportMode", "Calculate" ) );
 				modelImporter.normalSmoothingAngle = EditorPrefs.GetFloat( prefix + ".NormalSmoothingAngle", 60.0f );
 				modelImporter.splitTangentsAcrossSeams = EditorPrefs.GetBool( prefix + ".SplitTangentsAcrossSeams", false );
  
 				// Materials
 				modelImporter.importMaterials = EditorPrefs.GetBool( prefix + ".ImportMaterials", false );
 				modelImporter.materialName = (ModelImporterMaterialName)System.Enum.Parse( typeof(ModelImporterMaterialName),
 								EditorPrefs.GetString( prefix + ".MaterialName", "BasedOnTextureName" ) );
 				modelImporter.materialSearch = (ModelImporterMaterialSearch)System.Enum.Parse( typeof(ModelImporterMaterialSearch),
 								EditorPrefs.GetString( prefix + ".MaterialSearch", "RecursiveUp" ) );
  
 				Debug.Log( "ModelImportProcessor::OnPreprocessModel, Using custom import settings of preset '" + presetName + "'." );
 			}
 		}
 	}
コード例 #21
0
    void ShowUpdateReferenceClip()
    {
        if (targets.Length > 1 || m_CopyAvatar.boolValue || !m_Avatar || !m_Avatar.isValid)
        {
            return;
        }

        string[]      paths    = new string[0];
        ModelImporter importer = target as ModelImporter;

        if (importer.referencedClips.Length > 0)
        {
            foreach (string clipGUID in importer.referencedClips)
            {
                ArrayUtility.Add(ref paths, AssetDatabase.GUIDToAssetPath(clipGUID));
            }
        }

        // Show only button if some clip reference this avatar.
        if (paths.Length > 0 && GUILayout.Button(Styles.UpdateReferenceClips, GUILayout.Width(150)))
        {
            foreach (string path in paths)
            {
                SetupReferencedClip(path);
            }

            try
            {
                AssetDatabase.StartAssetEditing();
                foreach (string path in paths)
                {
                    AssetDatabase.ImportAsset(path);
                }
            }
            finally
            {
                AssetDatabase.StopAssetEditing();
            }
        }
    }
コード例 #22
0
        // LGC
        private void OnPreprocessModel()
        {
            string        fullPath = Util.GetFullPath(assetImporter.assetPath);
            ModelImporter mi       = assetImporter as ModelImporter;

            if (AssetMap.ContainsKey(fullPath))
            {
                string texturePath = AssetMap[fullPath];

                mi.materialSearch        = ModelImporterMaterialSearch.Local;
                mi.materialName          = ModelImporterMaterialName.BasedOnTextureName;
                mi.normalCalculationMode = ModelImporterNormalCalculationMode.Unweighted_Legacy;
                mi.importNormals         = ModelImporterNormals.Import;
                mi.importMaterials       = true;
                mi.importAnimation       = false;
                mi.importBlendShapes     = false;

#if UNITY_2018
                mi.materialLocation          = ModelImporterMaterialLocation.InPrefab;
                EditorApplication.delayCall += () => {
                    Material mat    = null;
                    Object[] things = AssetDatabase.LoadAllAssetRepresentationsAtPath(assetImporter.assetPath);
                    foreach (Object o in things)
                    {
                        if (o is Material)
                        {
                            mat        = o as Material;
                            mat.shader = TheShader;
                        }
                    }
                    if (mat)
                    {
                        EditorApplication.delayCall += () => {
                            mat.mainTexture = AssetDatabase.LoadAssetAtPath <Texture2D>(Util.FixedRelativePath(texturePath));
                        };
                    }
                };
#endif
            }
        }
コード例 #23
0
//		[MenuItem("L7/批量更改动画文件")]
//		static void ModifyAnimationBatch() {
//			string path = AssetDatabase.GetAssetPath(Selection.activeGameObject);
//		}


        public static void ModifyAnimationBatch(string existPath)
        {
            var path = Path.GetDirectoryName(existPath);

            if (path != null)
            {
                string[] filePaths = Directory.GetFiles(path, "*.meta", SearchOption.TopDirectoryOnly);


                foreach (var filePath in filePaths)
                {
                    if (filePath.Contains(@"@"))
                    {
                        ModifyClip(filePath);
                    }
                    if (filePath.Contains(@"@attack"))
                    {
                        ModifyAnimation(filePath, EventType.OnAttack);
                    }
                    else if (filePath.Contains(@"@skill"))
                    {
                        ModifyAnimation(filePath, EventType.OnUseSkill);
                    }
                    else if (filePath.Contains(@"@death"))
                    {
                        ModifyAnimation(filePath, EventType.OnDeathAnimationEnd);
                    }
                    else if (filePath.Contains(@"@idle") || filePath.Contains(@"@run") || filePath.Contains(@"@stand"))
                    {
                        ModifyAnimation(filePath, EventType.None);
                    }
                    if (filePath.Contains(@"@"))
                    {
                        string        animationFilePath = filePath.Remove(filePath.LastIndexOf(@".meta", StringComparison.Ordinal));
                        ModelImporter modelImporter     = (ModelImporter)AssetImporter.GetAtPath(animationFilePath);
                        modelImporter.SaveAndReimport();
                    }
                }
            }
        }
コード例 #24
0
        void OnPreprocessModel()
        {
            // Check if this is the first import. If not, skip.
            if (!assetImporter.importSettingsMissing)
            {
                return;
            }

            LogAction("First import of a model, changing import settings.");


            ModelImporter modelImporter = assetImporter as ModelImporter;

            if (ImporterSettings.BlendShapeNormals != ImporterSettingsEnums.BlendShapeNormalsMode.Default)
            {
                if (ImporterSettings.BlendShapeNormals == ImporterSettingsEnums.BlendShapeNormalsMode.Import)
                {
                    // Enable import blendshape normals automatically
                    modelImporter.importBlendShapeNormals = ModelImporterNormals.Import;
                }
                else if (ImporterSettings.BlendShapeNormals == ImporterSettingsEnums.BlendShapeNormalsMode.None)
                {
                    // Disable blendshape normals automatically
                    modelImporter.importBlendShapeNormals = ModelImporterNormals.None;
                }
                else
                {
                    // Set "legacy blend shapes" enabled automatically
                    PropertyInfo legacyBlendShapeNormalsEnabled = modelImporter.GetType().GetProperty("legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes", BindingFlags.NonPublic | BindingFlags.Instance);
                    legacyBlendShapeNormalsEnabled.SetValue(modelImporter, true);
                }
            }

            // tesselating, are we?
            modelImporter.keepQuads = ImporterSettings.KeepQuads;

            modelImporter.importCameras = ImporterSettings.ImportCameras;

            modelImporter.importTangents = (ModelImporterTangents)ImporterSettings.TangentsMode;
        }
コード例 #25
0
        public void LoadModel(string path, bool transformYup, double scale)
        {
            var importer = new ModelImporter();
            var mod      = importer.Load(path);

            if (mod == null || mod.Children.Count == 0)
            {
                return;
            }

            var model = (mod.Children[0] as GeometryModel3D);

            if (model == null)
            {
                return;
            }

            var mesh = model.Geometry as MeshGeometry3D;

            if (mesh == null)
            {
                return;
            }

            var transform = new Transform3DGroup();

            if (transformYup)
            {
                transform.Children.Add(new RotateTransform3D(new AxisAngleRotation3D(new Vector3D(1, 0, 0), 90)));
            }
            transform.Children.Add(new ScaleTransform3D(scale, scale, scale));

            for (int i = 0; i < mesh.Positions.Count; i++)
            {
                mesh.Positions[i] = transform.Transform(mesh.Positions[i]);
            }

            ScaleHeightOnly = false;
            Geometry        = mesh;
        }
コード例 #26
0
        internal Model3D GetModel3D(string path)
        {
            if (string.IsNullOrWhiteSpace(path))
            {
                return(null);
            }

            Model3D device = null;

            try
            {
                ModelImporter import = new ModelImporter();

                device = import.Load(path);
            }
            catch (Exception e)
            {
                // Logged exception
            }

            return(device);
        }
コード例 #27
0
    public void OnPreprocessModel()
    {
        if (Path.GetExtension(assetPath).ToLower() == ".fbx" && !assetPath.Contains("@"))
        {
            try
            {
                string path          = Path.GetDirectoryName(assetPath);
                string file_name     = Path.GetFileNameWithoutExtension(assetPath);
                string full_txt_path = path + "/" + file_name + ".txt";
                if (!File.Exists(full_txt_path))
                {
                    return;
                }

                using (StreamReader file_stream = new StreamReader(full_txt_path))
                {
                    string sAnimList = file_stream.ReadToEnd();

                    if (EditorUtility.DisplayDialog("FBX Animation Import from file", file_name, "Import", "Cancel"))
                    {
                        List <ModelImporterClipAnimation> list_clip = new List <ModelImporterClipAnimation>();
                        ParseAnimFile(sAnimList, ref list_clip);

                        ModelImporter modelImporter = assetImporter as ModelImporter;
                        modelImporter.animationType   = ModelImporterAnimationType.Legacy;
                        modelImporter.meshCompression = ModelImporterMeshCompression.Medium;
                        modelImporter.clipAnimations  = list_clip.ToArray();

                        EditorUtility.DisplayDialog("Imported animations", "Number of imported clips: " + modelImporter.clipAnimations.GetLength(0).ToString(), "OK");
                    }
                }
            }
            catch (Exception e)
            {
                Debug.LogError("导入出错:" + e.Message);
                EditorUtility.DisplayDialog("Imported animations", e.Message, "OK");
            }
        }
    }
コード例 #28
0
        /// <summary>
        /// Create a visible model of the STL file
        /// </summary>
        /// <param name="filename">The STL file with full extension</param>
        public void ViewNewStl(string filename)
        {
            // WTF!! No file
            if (!File.Exists(filename))
            {
                return;
            }

            // Check the file extension to be STL
            FileInfo fileInfo = new FileInfo(filename);

            if (fileInfo.Extension.ToLower() != ".stl")
            {
                return;
            }

            ModelColor = configuration.STLcolor;

            Filename = filename;

            // Create a model of the STL file



            ModelImporter modellImporter = new ModelImporter();

            modellImporter.DefaultMaterial =
                new DiffuseMaterial(
                    new SolidColorBrush((Color)ColorConverter.ConvertFromString(modellColor)));
            Model3DGroup model3DGroup = modellImporter.Load(filename);



            StlModel.Content = model3DGroup;


            myViewPort3D.CameraController.ResetCamera();
            myViewPort3D.CameraController.ZoomExtents(0);
        }
コード例 #29
0
 void BasicAssetOut.PickAssetAtPath <ElementType>(string path, Taker <ElementType> collector)
 {
     try {
         var contentFullPath = Path.GetDirectoryName(assetUnitInfo.localref) + "/" + path;
         if (typeof(ElementType) == (typeof(ModelImporter)))
         {
             var importer = (ElementType)(object)ModelImporter.GetAtPath(contentFullPath);
             collector.Take(importer);
         }
         else if (typeof(UnityEngine.Object).IsAssignableFrom(typeof(ElementType)))
         {
             try {
                 foreach (var asset in AssetDatabase.LoadAllAssetsAtPath(contentFullPath))
                 {
                     try {
                         var concreteAsset = (ElementType)(object)asset;
                         if (concreteAsset != null)
                         {
                             collector.Take(concreteAsset);
                             break;
                         }
                     } catch { }
                 }
             } catch {
                 collector.OnFail("StdEditTimeUnityAssetIO.PickAssetAtPath: ");
             }
         }
         else
         {
             if (File.Exists(contentFullPath))
             {
                 collector.Take(RequiredFuncs.FromJsonAtPath <ElementType>(contentFullPath));
             }
         }
     } catch (Exception e) {
         Debug.LogError(e);
     }
     collector.OnFinish();
 }
コード例 #30
0
        private void SetGeometry(string model)
        {
            Model3DGroup device = null;

            try
            {
                //Import 3D model file
                ModelImporter import = new ModelImporter();
                System.Windows.Media.Media3D.Material mat = MaterialHelper.CreateMaterial(
                    //new SolidColorBrush(Colors.SaddleBrown));
                    new SolidColorBrush(Colors.Pink));
                import.DefaultMaterial = mat;
                //Load the 3D model file
                device = import.Load(model);
            }
            catch (Exception e)
            {
                // Handle exception in case can not file 3D model
                MessageBox.Show("Exception Error : " + e.StackTrace);
            }
            Visual3DModel = device;
        }
コード例 #31
0
        /// <summary>
        /// Display 3D Model
        /// </summary>
        /// <param name="model">Path to the Model file</param>
        /// <returns>3D Model Content</returns>
        private Model3D Display3d(string model)
        {
            Model3D device = null;

            try
            {
                //Adding a gesture here
                viewPort3d.RotateGesture = new MouseGesture(MouseAction.LeftClick);

                //Import 3D model file
                ModelImporter import = new ModelImporter();

                //Load the 3D model file
                device = import.Load(model);
            }
            catch (Exception e)
            {
                // Handle exception in case can not file 3D model
                MessageBox.Show("Exception Error : " + e.StackTrace);
            }
            return(device);
        }
コード例 #32
0
    void OnPreprocessModel()
    {
        if (assetPath.Contains("Assets/Art_new/UI/"))
        {        //UI 模型;
            ModelImporter modelImporter = (ModelImporter)assetImporter;

            modelImporter.globalScale         = 1;
            modelImporter.meshCompression     = ModelImporterMeshCompression.Off;
            modelImporter.isReadable          = false;
            modelImporter.optimizeMesh        = true;
            modelImporter.addCollider         = false;
            modelImporter.swapUVChannels      = false;
            modelImporter.generateSecondaryUV = false;

            modelImporter.normalImportMode         = ModelImporterTangentSpaceMode.Calculate;
            modelImporter.tangentImportMode        = ModelImporterTangentSpaceMode.Calculate;
            modelImporter.normalSmoothingAngle     = 60;
            modelImporter.splitTangentsAcrossSeams = true;

            modelImporter.importMaterials = false;
        }
    }