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);
}
