MeshUsageFlags getUsageFromComponents(Mesh mesh, MeshFilter meshFilter) { if (!meshFilter || !mesh) { throw new System.ArgumentNullException(); } var meshColliders = meshFilter.gameObject.GetComponents <MeshCollider>(); foreach (var cur in meshColliders) { if (!cur) { continue; } if (!cur.sharedMesh) { continue; } if (cur.sharedMesh != mesh) { continue; } return(ExportUtility.getMeshUsageFlags(cur)); } return(MeshUsageFlags.None); }
static string saveResourceToPath <DstType, SrcType>(string baseDir, SrcType srcObj, int objIndex, ResId objId, int objCount, IndexedObjectConverter <SrcType, DstType> converter, System.Func <DstType, string> nameFunc, string baseName, bool showGui, System.Action <DstType> dstProcessor) where DstType : IFastJsonValue { if (showGui) { ExportUtility.showProgressBar( string.Format("Saving file #{0} of resource type {1}", objIndex + 1, baseName), "Writing json data", objIndex, objCount); } var dstObj = converter(srcObj, objIndex, objId); string fileName; if (dstProcessor != null) { dstProcessor(dstObj); } if (nameFunc != null) { fileName = makeJsonResourcePath(baseName, nameFunc(dstObj), objIndex); } else { fileName = makeJsonResourcePath(baseName, objIndex); } var fullPath = System.IO.Path.Combine(baseDir, fileName); dstObj.saveToJsonFile(fullPath); return(fileName); }
public void rebuildMesh() { if (!skinMeshRend) { return; } var resMap = new ResourceMapper(); //jsonMesh = new JsonMesh(new Mesh) var prefabRoot = ExportUtility.getLinkedRootPrefabAsset(skinMeshRend.gameObject); var assetSkeletonRoot = JsonSkeletonBuilder.findSkeletonRoot(skinMeshRend); var mesh = skinMeshRend.sharedMesh; jsonMesh = new JsonMesh(new MeshStorageKey(mesh, prefabRoot, assetSkeletonRoot), 0, resMap); var boneNames = skinMeshRend.bones.Select((arg) => arg.name).ToList(); origTransforms = skinMeshRend.bones.ToList(); if (skeletonRoot) { debugTransforms = Utility.findNamedTransforms(boneNames, skeletonRoot); } else { debugTransforms = null; } //var foundTransforms = boneNames.Select((arg) => ; }
bool saveResourceType <T>(List <T> resourceList, string baseFilename, string targetDir, string projectPath, bool showGui, Logger logger, System.Action <T, bool, Logger> callback, string singular, string plural) { Logger.makeValid(ref logger); logger.logFormat("Saving {2} to {0}, {1}", targetDir, projectPath, plural); var resourceIndex = 0; var numResources = resourceList.Count; var title = string.Format("Saving {1} for {0}", baseFilename, plural); foreach (var curResource in resourceList) { if (showGui) { if (ExportUtility.showCancellableProgressBar(title, string.Format("Saving {2} {0}/{1}", resourceIndex, numResources, singular), resourceIndex, numResources)) { logger.logErrorFormat("Resource copying cancelled by the user."); return(false); //break; } } if (callback != null) { callback(curResource, true, logger); } resourceIndex++; } return(true); }
void beginSelectedObjectsExport(){ var objects = ExportUtility.getSelectedGameObjects(); if (objects.Count <= 0) return; if (!checkTargetPath(targetPath)) return; var logger = new Logger(); var proj = JsonProject.fromObjects(objects.ToArray(), true); proj.saveToFile(targetPath, true, true, logger); ExportResultWindow.openWindow(logger); }
public static JsonSkeleton extractOriginalSkeleton(SkinnedMeshRenderer meshRend, Logger logger) { Logger.makeValid(ref logger); var rootPrefab = ExportUtility.getLinkedRootPrefabAsset(meshRend.gameObject); //PrefabUtility.FindPrefabRoot(meshRend.gameObject); if (!rootPrefab) { //now what? logger.logWarningFormat("Could not find original prefab for meshRenderer {0}({1})," + "falling back on generating unique skeleton, errors may occur", meshRend, meshRend.gameObject ); return(buildFromSkinMesh(meshRend)); } return(buildFromPrefabRoot(rootPrefab)); }
public ResId getRootPrefabId(GameObject obj, bool createMissing) { if (!obj) { return(ResId.invalid); //ExportUtility.invalidId; } var rootPrefab = ExportUtility.getLinkedRootPrefabAsset(obj); if (!rootPrefab) { return(ResId.invalid); //ExportUtility.invalidId; } var result = prefabs.getId(rootPrefab, createMissing, onNewRootPrefab); return(result); }
static bool saveResourcesToPath <DstType, SrcType, StorageType>( List <string> outObjectPaths, string baseDir, ResourceStorageWatcher <StorageType, SrcType> objects, IndexedObjectConverter <SrcType, DstType> converter, System.Func <DstType, string> nameFunc, string baseName, bool showGui, System.Action <DstType> dstProcessor = null) where DstType : IFastJsonValue { if (converter == null) { throw new System.ArgumentNullException("converter"); } bool result = false; try{ if (objects != null) { foreach (var curData in objects.getNewObjectsData()) { //lq begin var temp = saveResourceToPath( baseDir, curData.data, curData.index, curData.id, objects.numObjects, converter, nameFunc, baseName, showGui, dstProcessor ); if (string.IsNullOrEmpty(temp) == false) { outObjectPaths.Add(temp); result = true; } //end } objects.updateNumObjects(); //yup. I forgot that part. } return(result); } finally{ if (showGui) { ExportUtility.hideProgressBar(); } } }
void saveAssetFiles(ExternalAssetList externAssets, string baseFilename, bool showGui, Logger logger = null) { try{ Logger.makeValid(ref logger); logger.logFormat("Save resources entered"); string targetDir, projectPath; if (!checkResourceFolder(baseFilename, out targetDir, out projectPath, false)) { return; } var baseProjectName = System.IO.Path.GetFileNameWithoutExtension(baseFilename); var targetAssetPath = System.IO.Path.Combine(targetDir, baseProjectName); bool cancelled = false; if (!cancelled) { if (!saveTerrains(externAssets.terrains, baseFilename, targetAssetPath, projectPath, showGui, logger)) { cancelled = true; } } if (!cancelled) { if (!saveCubemaps(externAssets.cubemaps, baseFilename, targetAssetPath, projectPath, showGui, logger)) { cancelled = true; } } if (!cancelled) { if (!saveTextures(externAssets.textures, baseFilename, targetAssetPath, projectPath, showGui, logger)) { cancelled = true; } } } finally{ if (showGui) { ExportUtility.hideProgressBar(); } } }
bool addMaterialAsset(AssetInfo asset, bool showGui, Logger logger) { Logger.makeValid(ref logger); AssetDatabase.LoadAllAssetsAtPath(asset.path); var mainAsset = AssetDatabase.LoadMainAssetAtPath(asset.path); var mat = mainAsset as Material; if (!mainAsset || !mat) { logger.logErrorFormat("Could not load material at path {0}({1})", asset.path, asset.guid); return(true); } var id = resourceMapper.getMaterialId(mat); if (!ExportUtility.isValidId(id)) { logger.logWarningFormat("Could not create id for material {0}({1})", asset.path, asset.guid); } return(true); }
static List <GameObject> harvestAttachedObjects(Animator anim) { if (!anim) { throw new System.ArgumentNullException("anim"); } var result = new List <GameObject>(); ExportUtility.walkHierarchy(anim.gameObject, (curObj) => { if (ExportUtility.hasSupportedComponents(curObj) && (curObj != anim.gameObject)) { result.Add(curObj); } return(true); } ); return(result); }
bool addGameObjectAsset(AssetInfo asset, bool showGui, Logger logger) { Logger.makeValid(ref logger); AssetDatabase.LoadAllAssetsAtPath(asset.path); var mainAsset = AssetDatabase.LoadMainAssetAtPath(asset.path); var obj = mainAsset as GameObject; if (!mainAsset || !obj) { logger.logErrorFormat("Could not load GameObject at path {0}({1})", asset.path, asset.guid); return(true); } var id = resourceMapper.gatherPrefabData(obj); if (!ExportUtility.isValidId(id)) { logger.logWarningFormat("Could not create id for GameObject {0}({1})", asset.path, asset.guid); } return(true); }
public void saveToFile(string filename, bool showGui, bool saveResourceFiles, Logger logger = null) { try{ if (showGui) { ExportUtility.showProgressBar( string.Format("Saving file {0}", System.IO.Path.GetFileName(filename)), "Writing json data", 0, 1); } string targetDir; string projectPath; checkResourceFolder(filename, out targetDir, out projectPath, true); string baseName = System.IO.Path.GetFileNameWithoutExtension(filename); string filesDir = System.IO.Path.Combine(targetDir, baseName); // + "_data"); if (showGui) { confirmAndEraseExistingDirectory(filesDir); } System.IO.Directory.CreateDirectory(filesDir); externResourceList = resourceMapper.saveResourceToFolder(filesDir, showGui, scenes, logger, saveResourceFiles); Utility.saveStringToFile(filename, toJsonString()); if (!saveResourceFiles) { return; } saveAssetFiles(externResourceList.externalAssets, filename, showGui, logger); } finally{ //Otherwise progress bar can get stuck, blocking entirety of editor if (showGui) { ExportUtility.hideProgressBar(); } } }
public static void exportSelectedObjectsProj(MenuCommand menuCommand) { var objects = ExportUtility.getSelectedGameObjects(); if (objects.Count <= 0) { return; } var path = EditorUtility.SaveFilePanel("Export selected objects", "", objects[0].name, "json"); if (path == string.Empty) { return; } var logger = new Logger(); var proj = JsonProject.fromObjects(objects.ToArray(), true); proj.saveToFile(path, true, true, logger); ExportResultWindow.openWindow(logger); }
public static JsonScene fromObjects(GameObject[] args, ResourceMapper resMap, bool showGui) { try{ var result = new JsonScene(); var objMap = new GameObjectMapper(); foreach (var curObj in args) { objMap.gatherObjectIds(curObj); } foreach (var curObj in objMap.objectList) { resMap.gatherPrefabData(curObj); } for (int i = 0; i < objMap.objectList.Count; i++) { /*TODO: The constructor CAN add more data, but most of it would've been added prior to this point. * Contempalting whether to enforce it strictly or not.*/ if (showGui) { ExportUtility.showProgressBar("Collecting scene data", string.Format("Adding scene object {0}/{1}", i, objMap.numObjects), i, objMap.objectList.Count); } var newObj = new JsonGameObject(objMap.objectList[i], objMap, resMap); result.objects.Add(newObj); } return(result); } finally{ if (showGui) { ExportUtility.hideProgressBar(); } } }
public ResId getPrefabObjectId(GameObject obj, bool createMissing) { if (!obj) { return(ResId.invalid); //ExportUtility.invalidId; } var linkedPrefab = ExportUtility.getLinkedPrefab(obj); if (!linkedPrefab) { return(ResId.invalid); //ExportUtility.invalidId; } var rootPrefabId = getRootPrefabId(obj, createMissing); if (!ExportUtility.isValidId(rootPrefabId)) { return(ResId.invalid); //ExportUtility.invalidId; } var rootPrefab = prefabs.getObject(rootPrefabId); var prefabMapper = prefabObjects[rootPrefab]; return(prefabMapper.getId(linkedPrefab)); }
bool processDataList <Data>(List <Data> assets, bool showGui, string titleMsgStart, string assetMsgStart, DataProcessingDelegate <Data> callback, Logger logger) { var title = string.Format("{0} \"{1}\"", titleMsgStart, getProjectName()); for (int i = 0; i < assets.Count; i++) { if (showGui) { if (ExportUtility.showCancellableProgressBar(title, string.Format("{2} {0}/{1}", i, assets.Count, assetMsgStart), i, assets.Count)) { logger.logErrorFormat("Export was cancelled by the user"); ExportUtility.hideProgressBar(); return(false); } } if (callback != null) { callback(assets[i], showGui, logger); } } return(true); }
public JsonGameObject(GameObject obj, GameObjectMapper objMap, ResourceMapper resMap) { name = obj.name; scenePath = obj.getScenePath(); instanceId = obj.GetInstanceID(); id = objMap.getId(obj); localPosition = obj.transform.localPosition; localRotation = obj.transform.localRotation; localScale = obj.transform.localScale; worldMatrix = obj.transform.localToWorldMatrix; localMatrix = worldMatrix; if (obj.transform.parent) { localMatrix = obj.transform.parent.worldToLocalMatrix * worldMatrix; } isStatic = obj.isStatic; var flags = GameObjectUtility.GetStaticEditorFlags(obj); lightMapStatic = (flags & StaticEditorFlags.LightmapStatic) != 0; occluderStatic = (flags & StaticEditorFlags.OccluderStatic) != 0; occludeeStatic = (flags & StaticEditorFlags.OccludeeStatic) != 0; navigationStatic = (flags & StaticEditorFlags.NavigationStatic) != 0; reflectionProbeStatic = (flags & StaticEditorFlags.ReflectionProbeStatic) != 0; activeSelf = obj.activeSelf; activeInHierarchy = obj.activeInHierarchy; //var prefType = PrefabUtility.GetPrefabType(obj); //prefabType = prefType.ToString(); prefabRootId = resMap.getRootPrefabId(obj, true); prefabObjectId = resMap.getPrefabObjectId(obj, true); prefabInstance = Utility.isPrefabInstance(obj) || Utility.isPrefabModelInstance(obj); //prefabInstance = (prefType == PrefabType.PrefabInstance) || (prefType == PrefabType.ModelPrefabInstance); renderer = JsonRendererData.makeRendererArray(obj.GetComponent <Renderer>(), resMap); light = JsonLight.makeLightArray(obj.GetComponent <Light>()); reflectionProbes = ExportUtility.convertComponents <ReflectionProbe, JsonReflectionProbe>(obj, (c) => new JsonReflectionProbe(c, resMap) ); terrains = ExportUtility.convertComponents <Terrain, JsonTerrain>(obj, (c) => new JsonTerrain(c, resMap) ); skinRenderers = ExportUtility.convertComponentsList <SkinnedMeshRenderer, JsonSkinRendererData>(obj, (c) => new JsonSkinRendererData(c, objMap, resMap) ); int colliderIndex = 0; colliders = ExportUtility.convertComponentsList <Collider, JsonCollider>( obj, (arg) => new JsonCollider(arg, colliderIndex++, resMap) ).Where(c => c.isSupportedType()).ToList(); for (int i = colliders.Count - 1; i >= 0; i--) { var curCollider = colliders[i]; if ((curCollider == null) || !curCollider.isSupportedType()) { colliders.RemoveAt(i); } } rigidbodies = ExportUtility.convertComponentsList <Rigidbody, JsonRigidbody>( obj, (arg) => new JsonRigidbody(arg) ); joints = ExportUtility.convertComponentsList <Joint, JsonPhysicsJoint>( obj, (arg) => new JsonPhysicsJoint(arg) ); /* * if (rigidbodies.Count > 1){ * //Logger.log * } */ ///..... I think those can be replaced with linq queries (-_-) /* * animators = obj.GetComponents<Animator>().Where((arg) => arg) * .Select((Animator arg) => new JsonAnimator(arg, resMap)) * .ToList();*/ animators = ExportUtility.convertComponentsList <Animator, JsonAnimator>(obj, (c) => new JsonAnimator(c, resMap)); var meshFilter = obj.GetComponent <MeshFilter>(); if (meshFilter) { mesh = resMap.getOrRegMeshId(meshFilter); } foreach (Transform curChild in obj.transform) { var childId = objMap.getId(curChild.gameObject); /* ???? * if (childId < 0){ * //throw new System.ArgumentException("Could not find child id * } */ if (!childId.isValid) { } //var childId = objMap.getId(curChild.gameObject); children.Add(childId); childNames.Add(curChild.name); } if (obj.transform.parent) { parentName = obj.transform.parent.name; parent = objMap.findId(obj.transform.parent.gameObject); } }
void sampleMatrixCurves(ResourceMapper resMap, AnimationSampler providedSampler = null) { var skelId = resMap.skelRegistry.registerSkeleton(animator.transform, true); if (!ExportUtility.isValidId(skelId)) { throw new System.ArgumentException( string.Format("Skeleton not found for clip \"{0}\" and animator \"{1}\"", clip, animator)); } var skeleton = resMap.skelRegistry.getSkeletonById(skelId); var prefabAnim = Utility.getSrcPrefabAssetObject(animator, false); if (providedSampler != null) { var sampled = providedSampler.sampleClip(clip); matrixCurves = sampled; //.matrixCurves; //sampledFloatCurves = sampled.floatCurves; } else { using (var sampler = new AnimationSampler(prefabAnim, skeleton)){ var sampled = sampler.sampleClip(clip); matrixCurves = sampled; //.matrixCurves; //sampledFloatCurves = sampled.floatCurves; } } matrixCurves.forEach((obj) => obj.simpleCompress()); #if false //Black magic: on! //Spawning a duplicate var spawnedAnimator = GameObject.Instantiate(prefabAnim); if (!spawnedAnimator) { throw new System.Exception("Instantiating of original object failed while sampling animation"); } var transformRoot = spawnedAnimator.transform; var foundTransforms = Utility.findNamedTransforms( skeleton.bones.Select((arg) => arg.name).ToList(), transformRoot); //This needs to be moved elsewhere. var guidName = System.Guid.NewGuid().ToString("N"); var animControllerBaseAssetPath = string.Format("Assets/tmp-remapController-{0}.controller", guidName); Debug.LogFormat("guid: {0}, basePath: {1}", guidName, animControllerBaseAssetPath); var animControllerAssetPath = AssetDatabase.GenerateUniqueAssetPath(animControllerBaseAssetPath); Debug.LogFormat("generated path: {0}", animControllerAssetPath); var newController = UnityEditor.Animations.AnimatorController.CreateAnimatorControllerAtPath( animControllerAssetPath); var stateMachine = newController.layers[0].stateMachine; var stateName = "clip"; var state = newController.layers[0].stateMachine.AddState(stateName); stateMachine.defaultState = state; spawnedAnimator.runtimeAnimatorController = newController; var firstTime = 0.0f; var lastTime = clip.length; var timeStep = 1.0f / clip.frameRate; spawnedAnimator.Play(stateName, 0, 0.0f); for (int transformIndex = 0; transformIndex < foundTransforms.Count; transformIndex++) { var curTransform = foundTransforms[transformIndex]; var newCurve = new JsonAnimationMatrixCurve(); newCurve.objectName = skeleton.bones[transformIndex].name; matrixCurves.Add(newCurve); } for (float t = firstTime; t <= lastTime; t += timeStep) { clip.SampleAnimation(spawnedAnimator.gameObject, t); for (int transformIndex = 0; transformIndex < foundTransforms.Count; transformIndex++) { var curTransform = foundTransforms[transformIndex]; if (!curTransform) { continue; } matrixCurves[transformIndex].addKey(t, curTransform, spawnedAnimator.transform); } ///sampleSingleFramePoints(spawnedAnimator, boneIds, t/lastTime); } foreach (var cur in matrixCurves) { cur.simpleCompress(); } if (spawnedAnimator) { GameObject.DestroyImmediate(spawnedAnimator.gameObject); } if (newController) { AssetDatabase.DeleteAsset(animControllerAssetPath); } #endif }
public bool hasObject(Resource obj) { return(ExportUtility.isValidId(getId(obj, false))); }
bool collectProjectResources(bool showGui, Logger logger) { try{ var projectName = Application.productName; var title = string.Format("Processing proejct \"{0}\"", projectName); if (showGui) { ExportUtility.showProgressBar(title, "Gathering all assets", 0, 1); } var allAssets = AssetDatabase.FindAssets("t:object").ToList(); logger.logFormat("{0} assets found", allAssets.Count); title = string.Format("Enumerating assets for \"{0}\"", projectName); var numAssets = allAssets.Count; var assetList = new ProjectAssetList(); if (!processDataList(allAssets, showGui, "Enumerating assets for", "Processing asset", (data_, gui_, log_) => { assetList.addAssetFromGuid(data_, log_); return(true); }, logger)) { return(false); } logger.logFormat("Asset information: textures: {0}; materials: {1}; gameObjects: {2}; " + "terrains: {3}; scenes: {4}; defaultAssets: {5}; unsupported: {6};", assetList.textures.Count, assetList.materials.Count, assetList.gameObjects.Count, assetList.terrains.Count, assetList.scenes.Count, assetList.defaultAssets.Count, assetList.unsupportedAssets.Count); if (!processDataList(assetList.terrains, showGui, "Registering terrains for", "Processing terrain", addTerrainAsset, logger)) { return(false); } if (!processDataList(assetList.textures, showGui, "Registering textures for", "Processing texture", addTextureAsset, logger)) { return(false); } if (!processDataList(assetList.materials, showGui, "Registering materials for", "Processing material", addMaterialAsset, logger)) { return(false); } if (!processDataList(assetList.gameObjects, showGui, "Registering prefabs for", "Processing prefab", addGameObjectAsset, logger)) { return(false); } var sceneSetup = UnityEditor.SceneManagement.EditorSceneManager.GetSceneManagerSetup(); var processResult = processDataList(assetList.scenes, showGui, "Registering scenes for", "Processing scene", addSceneAsset, logger); UnityEditor.SceneManagement.EditorSceneManager.RestoreSceneManagerSetup(sceneSetup); if (!processResult) { return(false); } } finally{ if (showGui) { ExportUtility.hideProgressBar(); } } return(true); }
public JsonMaterial(Material mat, ResourceMapper resMap) { name = mat.name; //TODO: Further investigation shows that this is likely going to return -1 for all new materials. id = resMap.findMaterialId(mat); //exp.materials.findId(mat); renderQueue = mat.renderQueue; var path = AssetDatabase.GetAssetPath(mat); this.path = path; shader = mat.shader.name; supportedShader = isSupportedShaderName(shader); mainTexture = resMap.getTextureId(mat.mainTexture); mainTextureOffset = mat.mainTextureOffset; mainTextureScale = mat.mainTextureScale; color = getColor(mat, ParamNames.mainColor, Color.white); //mat.color; useNormalMap = mat.IsKeywordEnabled(Keywords.normalMap); //"_NORMALMAP"); useAlphaTest = mat.IsKeywordEnabled(Keywords.alphaTestOn); //"_ALPHATEST_ON"); useAlphaBlend = mat.IsKeywordEnabled(Keywords.alphaBlendOn); //"_ALPHABLEND_ON"); useAlphaPremultiply = mat.IsKeywordEnabled(Keywords.alphaPremultiplyOn); //"_ALPHAPREMULTIPLY_ON"); useEmission = mat.IsKeywordEnabled(Keywords.emission); //"_EMISSION"); useParallax = mat.IsKeywordEnabled(Keywords.parallaxMap); //"_PARALLAXMAP"); useDetailMap = mat.IsKeywordEnabled(Keywords.detailMulX2); //"_DETAIL_MULX2"); useMetallic = mat.IsKeywordEnabled(Keywords.metallicGlossMap); //"_METALLICGLOSSMAP"); useSpecular = mat.IsKeywordEnabled(Keywords.specGlossMap); //"_SPECCGLOSSMAP"); albedoTex = getTexId(mat, TexParamNames.main, resMap); specularTex = getTexId(mat, TexParamNames.specular, resMap); metallicTex = getTexId(mat, TexParamNames.metallic, resMap); normalMapTex = getTexId(mat, TexParamNames.normal, resMap); occlusionTex = getTexId(mat, TexParamNames.occlusion, resMap); parallaxTex = getTexId(mat, TexParamNames.parallax, resMap); emissionTex = getTexId(mat, TexParamNames.emission, resMap); detailMaskTex = getTexId(mat, TexParamNames.detailMask, resMap); detailAlbedoTex = getTexId(mat, TexParamNames.detailAlbedo, resMap); detailNormalMapTex = getTexId(mat, TexParamNames.detailNormal, resMap); detailAlbedoScale = getTextureScale(mat, TexParamNames.detailAlbedo); //mat.GetTextureScale(TexParamNames.detailAlbedo); detailAlbedoOffset = getTextureOffset(mat, TexParamNames.detailAlbedo); //mat.GetTextureOffset(TexParamNames.detailAlbedo); detailNormalMapScale = getFloat(mat, ParamNames.detailNormalMapScale, 1.0f); alphaCutoff = getFloat(mat, ParamNames.cutoff, 1.0f); smoothness = getFloat(mat, ParamNames.glossiness, 0.5f); smoothnessScale = getFloat(mat, ParamNames.glossinessScale, 1.0f); specularColor = getColor(mat, ParamNames.specularColor, Color.white); metallic = getFloat(mat, ParamNames.metallic, 0.5f); bumpScale = getFloat(mat, ParamNames.bumpScale, 1.0f); parallaxScale = getFloat(mat, ParamNames.parallax, 1.0f); occlusionStrength = getFloat(mat, ParamNames.occlusionStrength, 1.0f); emissionColor = getColor(mat, ParamNames.emissionColor, Color.black); detailMapScale = getFloat(mat, ParamNames.detailNormalMapScale, 1.0f); secondaryUv = getFloat(mat, ParamNames.secondaryUv, 1.0f); blendMode = Mathf.RoundToInt(getFloat(mat, ParamNames.blendMode, 0.0f)); smoothnessMapChannel = (int)getFloat(mat, ParamNames.smoothnessMapChannel, 0.0f); specularHighlights = getFloat(mat, ParamNames.specularHighlights, 1.0f); glossyReflections = getFloat(mat, ParamNames.glossyReflections, 1.0f); hasMetallic = mat.HasProperty(ParamNames.metallic) && mat.HasProperty(TexParamNames.metallic); hasSpecular = mat.HasProperty(TexParamNames.specular) && mat.HasProperty(ParamNames.specularColor); hasEmissionColor = mat.HasProperty(ParamNames.emissionColor) && (emissionColor.maxColorComponent > 0.01f); hasEmission = hasEmissionColor || ExportUtility.isValidId(emissionTex); //(emissionTex >= 0); }