using UnityEditor;
using System.Collections.Generic;
using System;
using System.Collections;
using UnityEngine;
using System.IO;
using System.Runtime.InteropServices;
namespace Daz3D
{
[UnityEditor.AssetImporters.ScriptedImporter(1, "dtu", 0x7FFFFFFF)]
public class Daz3DDTUImporter : UnityEditor.AssetImporters.ScriptedImporter
{
public static bool AutoImportDTUChanges = true;
public static bool GenerateUnityPrefab = true;
public static bool ReplaceSceneInstances = true;
public static bool AutomateMecanimAvatarMappings = true;
public static bool ReplaceMaterials = true;
public static bool EnableDForceSupport = false;
public static bool UseNewShaders = false;
public static void ResetOptions()
{
AutoImportDTUChanges = true;
GenerateUnityPrefab = true;
ReplaceSceneInstances = true;
AutomateMecanimAvatarMappings = true;
ReplaceMaterials = true;
EnableDForceSupport = false;
UseNewShaders = false;
}
[Serializable]
public class ImportEventRecord
{
public DateTime Timestamp = DateTime.Now;
public struct Token
{
public string Text;
public UnityEngine.Object Selectable;
public bool EndLine;
}
public List<Token> Tokens = new List<Token>();
public bool Unfold = true;
internal void AddToken(string str, UnityEngine.Object obj = null, bool endline = false)
{
Tokens.Add(new Token() { Text = str, Selectable = obj, EndLine = endline });
}
}
public static Queue<ImportEventRecord> EventQueue = new Queue<ImportEventRecord>();
private static Dictionary<string, Material> s_StandardMaterialCollection = new Dictionary<string, Material>();
private static MaterialMap _map = null;
// DB (2021-05-25): dforceImport
private static DForceMaterialMap _dforceMap = null;
private const bool ENDLINE = true;
public static void EmptyEventQueue()
{
EventQueue = new Queue<ImportEventRecord>();
}
public enum DazFigurePlatform
{
Genesis8,
Genesis3,
Genesis2,
Victoria,
Genesis,
Michael,
TheFreak,
Victoria4,
Victoria4Elite,
Michael4,
Michael4Elite,
Stephanie4,
Aiko4
}
public static void FoldAll()
{
foreach (var record in EventQueue)
record.Unfold = false;
}
/// <summary>
/// Method called by Unity Editor when ImportAsset event occurs.
/// This will probably be the first DTU Brudge code which is executed
/// when the DTU Bridge is first installed into Unity.
/// </summary>
public override void OnImportAsset(UnityEditor.AssetImporters.AssetImportContext ctx)
{
if (AutoImportDTUChanges)
{
var dtuPath = ctx.assetPath;
var fbxPath = dtuPath.Replace(".dtu", ".fbx");
Import(dtuPath, fbxPath);
}
}
[MenuItem("Daz3D/Create Unity Prefab from selected DTU", false, 101)]
public static void MenuItemConvert()
{
var activeObject = Selection.activeObject;
var dtuPath = AssetDatabase.GetAssetPath(activeObject);
var fbxPath = dtuPath.Replace(".dtu", ".fbx");
Import(dtuPath, fbxPath);
}
[MenuItem("Daz3D/Create Unity Prefab from selected DTU", true)]
[MenuItem("Daz3D/Extract materials from selected DTU", true)]
[MenuItem("Assets/Daz3D/Create Unity Prefab", true)]
[MenuItem("Assets/Daz3D/Extract materials", true)]
public static bool ValidateDTUSelected()
{
var obj = Selection.activeObject;
// Return false if no transform is selected.
if (obj == null)
return false;
return (AssetDatabase.GetAssetPath(obj).ToLower().EndsWith(".dtu"));
}
public class MaterialMap
{
public MaterialMap(string path)
{
Path = path;
}
public void AddMaterial(UnityEngine.Material material)
{
if (material && !Map.ContainsKey(material.name))
Map.Add(material.name, material);
}
public string Path { get; set; }
public Dictionary<string, UnityEngine.Material> Map = new Dictionary<string, UnityEngine.Material>();
}
public class DForceMaterial
{
public DForceMaterial(DTUMaterial dtuMat)
{
name = dtuMat.MaterialName;
dtuMaterial = dtuMat;
}
public string name;
public DTUMaterial dtuMaterial;
/*
public static bool operator ==(Object x, Object y);
public static bool operator !=(Object x, Object y);
public static implicit operator bool(Object exists);
*/
}
public class DForceMaterialMap
{
public DForceMaterialMap(string path)
{
Path = path;
}
public void AddMaterial(DForceMaterial dforceMat)
{
if (dforceMat == null)
{
return;
}
if (!Map.ContainsKey(dforceMat.name))
Map.Add(dforceMat.name, dforceMat);
}
public string Path { get; set; }
public Dictionary<string, DForceMaterial> Map = new Dictionary<string, DForceMaterial>();
}
public static void Import(string dtuPath, string fbxPath)
{
DazCoroutine.StartCoroutine(ImportRoutine(dtuPath, fbxPath));
}
public static bool IsRenderPipelineDetected()
{
#if !USING_HDRP && !USING_URP && !USING_BUILTIN
ImportEventRecord record = new ImportEventRecord();
EventQueue.Enqueue(record);
record.AddToken("DTU Bridge must autodetect a RenderPipeline in order to continue.\nThis will involve updating Symbol Definitions and will trigger \nUnity Editor to recompile all scripts.");
return false;
#else
return true;
#endif
}
private static IEnumerator ImportRoutine(string dtuPath, string fbxPath)
{
//DEBUG
//Debug.LogError("dtuPath = [" + dtuPath + "] " + dtuPath.Length);
Daz3DBridge.ShowWindow();
Daz3DBridge.CurrentToolbarMode = Daz3DBridge.ToolbarMode.History; //force into history mode during import
Daz3DBridge.Progress = .03f;
yield return new WaitForEndOfFrame();
if (IsRenderPipelineDetected() == false)
{
// DB: Write path of asset to be imported in temporary file,
// this will be restored and continued after global script recompilation takes place.
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(dtuPath);
System.IO.File.WriteAllBytes("Assets/Daz3D/Resources/dtu_toload.txt", buffer);
yield return new WaitForEndOfFrame();
DetectRenderPipeline.RunOnce();
}
_map = new MaterialMap(dtuPath);
_dforceMap = new DForceMaterialMap(dtuPath);
while (!IrayShadersReady())
yield return new WaitForEndOfFrame();
var dtu = new DTU();
var routine = ImportDTURoutine(dtuPath, (d => dtu = d), .8f);
while (routine.MoveNext())
yield return new WaitForEndOfFrame();
if (dtu.AssetType == "Animation")
{
Daz3DBridge.Progress = 0;
_map = null;
_dforceMap = null;
yield break;
}
//ImportDTU(dtuPath);
if (dtu.AssetType == null)
{
Daz3DBridge.Progress = 0;
_map = null;
_dforceMap = null;
yield break;
}
DazFigurePlatform platform = DiscoverFigurePlatform(dtu);
Daz3DBridge.Progress = .9f;
yield return new WaitForEndOfFrame();
if (GenerateUnityPrefab)
GeneratePrefabFromFBX(fbxPath, platform);
Daz3DBridge.Progress = 1f;
yield return new WaitForEndOfFrame();
_map = null;
_dforceMap = null;
Daz3DBridge.Progress = 0;
// DB 2021-09-02: Show DTUImport complete dialog
EditorUtility.DisplayDialog("DTU Bridge Import", "Import Completed for " + dtuPath, "OK");
Daz3DBridge.AddDiffusionProfilePrompt();
yield break;
}
private static DazFigurePlatform DiscoverFigurePlatform(DTU dtu)
{
var token = dtu.AssetID.ToLower();
foreach(DazFigurePlatform dfp in Enum.GetValues(typeof (DazFigurePlatform)))
{
if (token.Contains(dfp.ToString().ToLower()))
return dfp;
}
return DazFigurePlatform.Genesis8;//default
}
private static bool IrayShadersReady()
{
#if USING_HDRP || USING_URP || USING_BUILTIN
if (
Shader.Find(DTU_Constants.shaderNameMetal) == null ||
Shader.Find(DTU_Constants.shaderNameSpecular) == null ||
Shader.Find(DTU_Constants.shaderNameIraySkin) == null ||
Shader.Find(DTU_Constants.shaderNameHair) == null ||
Shader.Find(DTU_Constants.shaderNameWet) == null ||
Shader.Find(DTU_Constants.shaderNameInvisible) == null
) {
return false;
}
return true;
#else
return false;
#endif
}
//// unused blocking method
//public static void ImportDTU(string path)
//{
// Debug.Log("ImportDTU for " + path);
// FoldAll();
// ImportEventRecord record = new ImportEventRecord();
// EventQueue.Enqueue(record);
// var dtu = DTUConverter.ParseDTUFile(path);
// var dtuObject = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
// // DB (2021-05-15): skip anim DTU
// if (dtu.AssetType == "Animation")
// {
// record.AddToken("Skipping prefab creation for animation DTU file: " + path);
// return;
// }
// record.AddToken("Imported DTU file: " + path);
// record.AddToken(dtuObject.name, dtuObject, ENDLINE);
// //UnityEngine.Debug.Log("DTU: " + dtu.AssetName + " contains: " + dtu.Materials.Count + " materials");
// record.AddToken("Generated materials: ");
// foreach (var dtuMat in dtu.Materials)
// {
// var material = dtu.ConvertToUnity(dtuMat);
// _map.AddMaterial(material);
// // DB (2021-05-25): DForce import
// if (dtu.IsDTUMaterialDForceEnabled(dtuMat))
// {
// _dforceMap.AddMaterial(new DForceMaterial(dtuMat));
// }
// record.AddToken(material.name, material);
// }
// record.AddToken(" based on DTU file.", null, ENDLINE);
// Daz3DBridge bridge = EditorWindow.GetWindow(typeof(Daz3DBridge)) as Daz3DBridge;
// if (bridge == null)
// {
// var consoleType = Type.GetType("ConsoleWindow,UnityEditor.dll");
// bridge = EditorWindow.CreateWindow<Daz3DBridge>(new[] { consoleType });
// }
// bridge?.Focus();
// //just a safeguard to keep the history data at a managable size (100 records)
// while (EventQueue.Count > 100)
// {
// EventQueue.Dequeue();
// }
//}
public static IEnumerator ImportDTURoutine(string path, Action<DTU> dtuOut, float progressLimit)
{
Debug.Log("ImportDTU for " + path);
FoldAll();
ImportEventRecord record = new ImportEventRecord();
EventQueue.Enqueue(record);
var dtu = DTUConverter.ParseDTUFile(path);
// DB (2021-05-15): skip DTU import if animation
if (dtu.AssetType == "Animation")
{
record.AddToken("Skipping prefab creation for animation DTU file: " + path);
Daz3DBridge.Progress = 0;
yield break;
}
dtuOut(dtu);
var dtuObject = AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(path);
record.AddToken("Imported DTU file: " + path);
record.AddToken(dtuObject.name, dtuObject, ENDLINE);
//UnityEngine.Debug.Log("DTU: " + dtu.AssetName + " contains: " + dtu.Materials.Count + " materials");
record.AddToken("Generated materials: ");
float progressIncrement = (progressLimit - Daz3DBridge.Progress) / dtu.Materials.Count;
for (int i = 0; i < dtu.Materials.Count; i++)
{
var dtuMat = dtu.Materials[i];
var material = dtu.ConvertToUnity(dtuMat);
_map.AddMaterial(material);
// DB (2021-05-25): DForce import
if (dtu.IsDTUMaterialDForceEnabled(dtuMat))
{
_dforceMap.AddMaterial(new DForceMaterial(dtuMat));
}
record.AddToken(material.name, material);
Daz3DBridge.Progress = Mathf.MoveTowards(Daz3DBridge.Progress, progressLimit, progressIncrement);
yield return new WaitForEndOfFrame();
}
record.AddToken(" based on DTU file.", null, ENDLINE);
Daz3DBridge bridge = EditorWindow.GetWindow(typeof(Daz3DBridge)) as Daz3DBridge;
if (bridge == null)
{
var consoleType = Type.GetType("ConsoleWindow,UnityEditor.dll");
bridge = EditorWindow.CreateWindow<Daz3DBridge>(new[] { consoleType });
}
bridge?.Focus();
//just a safeguard to keep the history data at a managable size (100 records)
while (EventQueue.Count > 100)
{
EventQueue.Dequeue();
}
yield break;
}
enum MaterialID //these positions map to the bitflags in the compiled HDRP lit shader
{
SSS = 0,
Standard = 1,
Anisotropy = 2,
Iridescence = 3,
SpecularColor = 4,
Translucent = 5
}
private enum StandardMaterialType
{
Arms,
Cornea,
Ears,
Eyelashes,
EyeMoisture_1,
EyeMoisture,
EyeSocket,
Face,
Fingernails,
Irises,
Legs,
Lips,
Mouth,
Pupils,
Sclera,
Teeth,
Toenails,
Torso
}
public static void GeneratePrefabFromFBX(string fbxPath, DazFigurePlatform platform)
{
var fbxPrefab = AssetDatabase.LoadAssetAtPath<GameObject>(fbxPath);
if (fbxPrefab == null)
{
Debug.LogWarning("no FBX model prefab found at " + fbxPath);
return;
}
if (PrefabUtility.GetPrefabAssetType(fbxPrefab) != PrefabAssetType.Model)
{
Debug.LogWarning(fbxPath + " is not a model prefab ");
return;
}
System.Reflection.MethodInfo resetPose = null;
System.Reflection.MethodInfo xferPose = null;
var avatarInstance = Instantiate(fbxPrefab);
avatarInstance.name = "AvatarInstance";
if (AutomateMecanimAvatarMappings)
{
var record = new ImportEventRecord();
ModelImporter importer = GetAtPath(fbxPath) as ModelImporter;
if (importer)
{
var description = importer.humanDescription;
DescribeHumanJointsForFigure(ref description, platform);
importer.humanDescription = description;
importer.avatarSetup = ModelImporterAvatarSetup.CreateFromThisModel;
// Genesis 8 is modeled in A-pose, so we correct to T-pose before configuring avatar joints
//using Unity's internal MakePoseValid method, which does a perfect job
if (platform == DazFigurePlatform.Genesis8 && false)
{
//use reflection to access AvatarSetupTool;
var setupToolType = Type.GetType("UnityEditor.AvatarSetupTool,UnityEditor.dll");
var boneWrapperType = Type.GetType("UnityEditor.AvatarSetupTool+BoneWrapper,UnityEditor.dll");
if (boneWrapperType != null && setupToolType != null)
{
var existingMappings = new Dictionary<string, string>();
var human = description.human;
for (var i = 0; i < human.Length; ++i)
existingMappings[human[i].humanName] = human[i].boneName;
var getModelBones = setupToolType.GetMethod("GetModelBones");
var getHumanBones = setupToolType.GetMethod("GetHumanBones", new[] { typeof(Dictionary<string, string>), typeof(Dictionary<Transform, bool>) });
var makePoseValid = setupToolType.GetMethod("MakePoseValid");
resetPose = setupToolType.GetMethod("CopyPose");
xferPose = setupToolType.GetMethod("TransferPoseToDescription");
if (getModelBones != null && getHumanBones != null && makePoseValid != null)
{
record.AddToken("Corrected Avatar Setup T-pose for Genesis8 figure: ", null);
record.AddToken(fbxPrefab.name, fbxPrefab, ENDLINE);
var modelBones = (Dictionary<Transform, bool>)getModelBones.Invoke(null, new object[] { avatarInstance.transform, false, null });
var humanBones = (ICollection<object>)getHumanBones.Invoke(null, new object[] { existingMappings, modelBones });
// a little dance to populate array of Unity's internal BoneWrapper type
var humanBonesArray = new object[humanBones.Count];
humanBones.CopyTo(humanBonesArray, 0);
Array destinationArray = Array.CreateInstance(boneWrapperType, humanBones.Count);
Array.Copy(humanBonesArray, destinationArray, humanBones.Count);
//This mutates the transforms (modelBones) via Bonewrapper class
makePoseValid.Invoke(null, new[] { destinationArray });
}
}
}
AssetDatabase.WriteImportSettingsIfDirty(fbxPath);
AssetDatabase.ImportAsset(fbxPath, ImportAssetOptions.ForceUpdate);
// i think this might unT-pose the gen8 skeleton instance
if (resetPose != null && xferPose != null)
{
SerializedObject modelImporterObj = new SerializedObject(importer);
var skeleton = modelImporterObj?.FindProperty("m_HumanDescription.m_Skeleton");
if (skeleton != null)
{
resetPose.Invoke(null, new object[] { avatarInstance, fbxPrefab });
//xferPose.Invoke(null, new object[] { skeleton, avatarInstance.transform });
}
}
DestroyImmediate(avatarInstance);
record.AddToken("Automated Mecanim avatar setup for " + fbxPrefab.name + ": ");
//a little dance to get the avatar just reimported
var allAvatars = Resources.FindObjectsOfTypeAll(typeof(Avatar));
var avatar = Array.Find(allAvatars, element => element.name.StartsWith(fbxPrefab.name));
if (avatar)
record.AddToken(avatar.name, avatar, ENDLINE);
}
else
{
Debug.LogWarning("Could not acquire importer for " + fbxPath + " ...could not automatically configure humanoid avatar.");
record.AddToken("Could not acquire importer for " + fbxPath + " ...could not automatically configure humanoid avatar.", null, ENDLINE);
}
EventQueue.Enqueue(record);
}
//remap the materials
var workingInstance = Instantiate(fbxPrefab);
workingInstance.name = "Daz3d_" + fbxPrefab.name;
var renderers = workingInstance.GetComponentsInChildren<Renderer>();
if (renderers?.Length == 0)
{
Debug.LogWarning("no renderers found for material remapping");
return;
}
var modelPath = AssetDatabase.GetAssetPath(fbxPrefab);
if (ReplaceMaterials)
{
foreach (var renderer in renderers)
{
var dict = new Dictionary<Material, Material>();
if (renderer.name.ToLower().Contains("eyelashes"))
renderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
// DB (2021-05-07): SANITY CHECK
if (renderer.sharedMaterials == null)
{
Debug.LogError("DB (2021-05-07), ERROR: GeneratePrefabFromFBX(): sharedMaterials is null!");
}
else
{
foreach (var keyMat in renderer.sharedMaterials)
{
// DB (2021-05-07): SANITY CHECK
if (keyMat == null)
{
Debug.LogError("DB (2021-05-07), ERROR: keyMat is NULL");
continue;
}
var key = keyMat.name;
key = Daz3D.Utilities.ScrubKey(key);
Material nuMat = null;
if (_map != null && _map.Map.ContainsKey(key))
{
nuMat = _map.Map[key];// the preferred uber/iRay based material generated by the DTUConverter
// DB (2021-05-25): dForce import
if (_dforceMap.Map.ContainsKey(key))
{
if (EnableDForceSupport)
ImportDforceToPrefab(key, renderer, workingInstance, keyMat);
//DForceMaterial dforceMat = _dforceMap.Map[key];
//GameObject parent = renderer.gameObject;
//SkinnedMeshRenderer skinned = parent.GetComponent<SkinnedMeshRenderer>();
//Cloth cloth;
//// add Unity Cloth Physics component to gameobject parent of the renderer
//if (parent.GetComponent<Cloth>() == null)
//{
// cloth = parent.AddComponent<Cloth>();
// // assign values from dtuMat
// cloth.stretchingStiffness = dforceMat.dtuMaterial.Get("Stretch Stiffness").Float;
// cloth.bendingStiffness = dforceMat.dtuMaterial.Get("Bend Stiffness").Float;
// cloth.damping = dforceMat.dtuMaterial.Get("Damping").Float;
// cloth.friction = dforceMat.dtuMaterial.Get("Friction").Float;
// // fix SkinnedMeshRenderer boundaries bug
// skinned.updateWhenOffscreen = true;
// // Add G8F cloth collision rig
// var searchResult = workingInstance.transform.Find("Cloth Collision Rig");
// GameObject collision_instance = (searchResult != null) ? searchResult.gameObject : null;
// if (collision_instance == null)
// {
// GameObject collision_prefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Daz3D/Resources/G8F Collision Rig.prefab");
// collision_instance = Instantiate<GameObject>(collision_prefab);
// collision_instance.name = "Cloth Collision Rig";
// collision_instance.transform.parent = workingInstance.transform;
// // merge cloth collision rig to figure root bone
// collision_instance.GetComponent<ClothCollisionAssigner>().mergeRig(skinned.rootBone);
// }
// ClothCollisionAssigner.ClothConfig clothConfig = new ClothCollisionAssigner.ClothConfig();
// clothConfig.m_ClothToManage = cloth;
// clothConfig.m_UpperBody = true;
// clothConfig.m_LowerBody = true;
// collision_instance.GetComponent<ClothCollisionAssigner>().addClothConfig(clothConfig);
//}
//else
//{
// cloth = parent.GetComponent<Cloth>();
//}
//// add clothtools to gameobject parent of renderer
//ClothTools clothTools;
//if (parent.GetComponent<ClothTools>() == null)
//{
// clothTools = parent.AddComponent<ClothTools>();
// clothTools.GenerateLookupTables();
//}
//else
//{
// clothTools = parent.GetComponent<ClothTools>();
//}
//int matIndex = Array.IndexOf(skinned.sharedMaterials, keyMat);
//// get vertex list for this material's submesh
//if (matIndex >= 0)
//{
// float simulation_strength;
// //// map the materical's submesh's vertices to the correct "Dynamics Strength"
// simulation_strength = dforceMat.dtuMaterial.Get("Dynamics Strength").Float;
// Debug.Log("DEBUG INFO: simulation strength: " + simulation_strength);
// //// DEBUG line to map simulation strength to material index
// //simulation_strength = matIndex;
// //// Tiered scaling function
// float adjusted_simulation_strength;
// //float strength_max = 1.0f;
// //float strength_min = 0.0f;
// float strength_scale_threshold = 0.5f;
// if (simulation_strength <= strength_scale_threshold)
// {
// //// stronger compression of values below threshold
// float scale = 0.075f;
// float offset = 0.2f;
// adjusted_simulation_strength = (simulation_strength - offset) * scale;
// }
// else
// {
// float offset = (strength_scale_threshold - 0.2f) * 0.075f; // offset = (threshold - previous tier's offset) * previous teir's scale
// float scale = 0.2f;
// adjusted_simulation_strength = (simulation_strength - offset) / (1 - offset); // apply offset, then normalize to 1.0
// adjusted_simulation_strength *= scale;
// }
// //// clamp to 0.0f to 0.2f
// float coeff_min = 0.0f;
// float coeff_max = 0.2f;
// adjusted_simulation_strength = (adjusted_simulation_strength > coeff_min) ? adjusted_simulation_strength : coeff_min;
// adjusted_simulation_strength = (adjusted_simulation_strength < coeff_max) ? adjusted_simulation_strength : coeff_max;
// //// Debug line for no scaling
// //adjusted_simulation_strength = simulation_strength;
// clothTools.SetSubMeshWeights(matIndex, adjusted_simulation_strength);
//}
}
}
else if (s_StandardMaterialCollection.ContainsKey(key))
{
nuMat = new Material(s_StandardMaterialCollection[key]);
//FixupStandardBasedMaterial(ref nuMat, fbxPrefab, keyMat.name, data);
}
else
{
var shader = Shader.Find("HDRP/Lit");
if (shader == null)
{
Debug.LogWarning("couldn't find HDRP/Lit shader");
continue;
}
nuMat = new Material(shader);
nuMat.CopyPropertiesFromMaterial(keyMat);
// just copy the textures, colors and scalars that are appropriate given the base material type
//DazMaterialPropertiesInfo info = new DazMaterialPropertiesInfo();
//CustomizeMaterial(ref nuMat, info);
var matPath = Path.GetDirectoryName(modelPath);
matPath = Path.Combine(matPath, fbxPrefab.name + "Daz3D_Materials");
matPath = AssetDatabase.GenerateUniqueAssetPath(matPath);
if (!Directory.Exists(matPath))
Directory.CreateDirectory(matPath);
//Debug.Log("obj path " + path);
AssetDatabase.CreateAsset(nuMat, matPath + "/Daz3D_" + keyMat.name + ".mat");
}
dict.Add(keyMat, nuMat);
}
//remap the meshes in the fbx prefab to the value materials in dict
var count = renderer.sharedMaterials.Length;
var copy = new Material[count]; //makes a copy
for (int i = 0; i < count; i++)
{
var key = renderer.sharedMaterials[i];
// DB (2021-05-07): SANITY CHECK
if (key == null || !dict.ContainsKey(key))
{
Debug.LogError("DB (2021-05-07), ERROR: GeneratePrefabFromFBX(): sharedMaterials[" + i + "] (" + renderer.sharedMaterials + ") returned invalid key.");
if (key != null)
Debug.LogError(" part 2: key==" + key);
else
Debug.LogError(" part 2: key==null");
}
else
{
Debug.Log("remapping: " + renderer.sharedMaterials[i].name + " to " + dict[key].name);
copy[i] = dict[key];//fill copy
}
}
renderer.sharedMaterials = copy;//overwrite sharedMaterials, because set indexer assigns to a copy
}
}
}
//write the prefab to the asset database
// Make sure the file name is unique, in case an existing Prefab has the same name.
var nuPrefabPathPath = Path.GetDirectoryName(modelPath);
nuPrefabPathPath = Path.Combine(nuPrefabPathPath, fbxPrefab.name + "_Prefab");
nuPrefabPathPath = AssetDatabase.GenerateUniqueAssetPath(nuPrefabPathPath);
if (!Directory.Exists(nuPrefabPathPath))
Directory.CreateDirectory(nuPrefabPathPath);
nuPrefabPathPath += "/Daz3D_" + fbxPrefab.name + ".prefab";
// For future refreshment
var component = workingInstance.AddComponent<Daz3DInstance>();
component.SourceFBX = fbxPrefab;
// Create the new Prefab.
var prefab = PrefabUtility.SaveAsPrefabAssetAndConnect(workingInstance, nuPrefabPathPath, InteractionMode.AutomatedAction);
Selection.activeGameObject = prefab;
//now, seek other instance(s) in the scene having been sourced from this fbx asset
var otherInstances = FindObjectsOfType<Daz3DInstance>();
int foundCount = 0;
var resultingInstance = workingInstance;
if (ReplaceSceneInstances)
{
foreach (var otherInstance in otherInstances)
{
if (otherInstance == component)//ignore this working instance
continue;
if (otherInstance.SourceFBX != fbxPrefab)//ignore instances of other assets
continue;
//for any found that flag ReplaceOnImport, delete that instance and replace with a copy of
//this one, at their respective transforms
if (otherInstance.ReplaceOnImport)
{
foundCount++;
var xform = otherInstance.transform;
var replacementInstance = PrefabUtility.InstantiatePrefab(prefab, xform.parent) as GameObject;
replacementInstance.transform.position = xform.position;
replacementInstance.transform.rotation = xform.rotation;
//var replacementInstance = Instantiate(prefab, xform.position, xform.rotation, xform.parent);
//PrefabUtility.RevertPrefabInstance(replacementInstance, InteractionMode.AutomatedAction);
DestroyImmediate(otherInstance.gameObject);
resultingInstance = replacementInstance;
}
}
}
//if no prior instances found, then don't destroy this instance
//since it appears to be the first one to arrive
if (foundCount > 0)
DestroyImmediate(workingInstance);
ImportEventRecord pfbRecord = new ImportEventRecord();
pfbRecord.AddToken("Created Unity Prefab: ");
pfbRecord.AddToken(prefab.name, prefab);
pfbRecord.AddToken(" and an instance in the scene: ");
pfbRecord.AddToken(resultingInstance.name, resultingInstance, ENDLINE);
EventQueue.Enqueue(pfbRecord);
//highlight/select the object in the scene view
Selection.activeGameObject = resultingInstance;
}
private static void ImportDforceToPrefab(string key, Renderer renderer, GameObject workingInstance, Material keyMat)
{
DForceMaterial dforceMat = _dforceMap.Map[key];
GameObject parent = renderer.gameObject;
SkinnedMeshRenderer skinned = parent.GetComponent<SkinnedMeshRenderer>();
Cloth cloth;
string valueLower = key.ToLower();
string assetNameLower = parent.name.ToLower();
string matNameLower = keyMat.name.ToLower();
if (
valueLower.Contains("hair") || assetNameLower.EndsWith("hair") || matNameLower.Contains("hair")
|| valueLower.Contains("moustache") || assetNameLower.EndsWith("moustache") || matNameLower.Contains("moustache")
|| valueLower.Contains("beard") || assetNameLower.EndsWith("beard") || matNameLower.Contains("beard")
)
{
// TODO: implement dForce hair support
Debug.LogWarning("Unofficial DTU: ImportDforceToPrefab() dForce hair is currently not supported: " + parent.name);
return;
}
if (skinned == null)
{
// TODO: check if regular mesh renderer and upgrade if appropriate
Debug.LogWarning("Unofficial DTU: ImportDforceToPrefab() gameojbect unsupported: it does not have a skinned mesh renderer: " + parent.name);
return;
}
else if (skinned.sharedMesh.vertexCount > 40000)
{
int numverts = skinned.sharedMesh.vertexCount;
Debug.LogWarning("Unofficial DTU: ImportDforceToPrefab() gameojbect unsupported: too many vertices: " + parent.name + " (" + numverts.ToString() + ")");
return;
}
// add Unity Cloth Physics component to gameobject parent of the renderer
if (parent.GetComponent<Cloth>() == null)
{
cloth = parent.AddComponent<Cloth>();
// assign values from dtuMat
cloth.stretchingStiffness = dforceMat.dtuMaterial.Get("Stretch Stiffness").Float;
cloth.bendingStiffness = dforceMat.dtuMaterial.Get("Bend Stiffness").Float;
cloth.damping = dforceMat.dtuMaterial.Get("Damping").Float;
cloth.friction = dforceMat.dtuMaterial.Get("Friction").Float;
// fix SkinnedMeshRenderer boundaries bug
skinned.updateWhenOffscreen = true;
// Add G8F cloth collision rig
var searchResult = workingInstance.transform.Find("Cloth Collision Rig");
GameObject collision_instance = (searchResult != null) ? searchResult.gameObject : null;
if (collision_instance == null)
{
GameObject collision_prefab = AssetDatabase.LoadAssetAtPath<GameObject>("Assets/Daz3D/Resources/G8F Collision Rig.prefab");
collision_instance = Instantiate<GameObject>(collision_prefab);
collision_instance.name = "Cloth Collision Rig";
collision_instance.transform.parent = workingInstance.transform;
// merge cloth collision rig to figure root bone
collision_instance.GetComponent<ClothCollisionAssigner>().mergeRig(skinned.rootBone);
}
ClothCollisionAssigner.ClothConfig clothConfig = new ClothCollisionAssigner.ClothConfig();
clothConfig.m_ClothToManage = cloth;
clothConfig.m_UpperBody = true;
clothConfig.m_LowerBody = true;
collision_instance.GetComponent<ClothCollisionAssigner>().addClothConfig(clothConfig);
}
else
{
cloth = parent.GetComponent<Cloth>();
}
// add clothtools to gameobject parent of renderer
ClothTools clothTools;
if (parent.GetComponent<ClothTools>() == null)
{
clothTools = parent.AddComponent<ClothTools>();
clothTools.GenerateLookupTables();
}
else
{
clothTools = parent.GetComponent<ClothTools>();
}
int matIndex = Array.IndexOf(skinned.sharedMaterials, keyMat);
// get vertex list for this material's submesh
if (matIndex >= 0)
{
float simulation_strength;
//// map the materical's submesh's vertices to the correct "Dynamics Strength"
simulation_strength = dforceMat.dtuMaterial.Get("Dynamics Strength").Float;
Debug.Log("DEBUG INFO: simulation strength: " + simulation_strength);
//// DEBUG line to map simulation strength to material index
//simulation_strength = matIndex;
//// Tiered scaling function
float adjusted_simulation_strength;
//float strength_max = 1.0f;
//float strength_min = 0.0f;
float strength_scale_threshold = 0.5f;
if (simulation_strength <= strength_scale_threshold)
{
//// stronger compression of values below threshold
float scale = 0.075f;
float offset = 0.2f;
adjusted_simulation_strength = (simulation_strength - offset) * scale;
}
else
{
float offset = (strength_scale_threshold - 0.2f) * 0.075f; // offset = (threshold - previous tier's offset) * previous teir's scale
float scale = 0.2f;
adjusted_simulation_strength = (simulation_strength - offset) / (1 - offset); // apply offset, then normalize to 1.0
adjusted_simulation_strength *= scale;
}
//// clamp to 0.0f to 0.2f
float coeff_min = 0.0f;
float coeff_max = 0.2f;
adjusted_simulation_strength = (adjusted_simulation_strength > coeff_min) ? adjusted_simulation_strength : coeff_min;
adjusted_simulation_strength = (adjusted_simulation_strength < coeff_max) ? adjusted_simulation_strength : coeff_max;
//// Debug line for no scaling
//adjusted_simulation_strength = simulation_strength;
clothTools.SetSubMeshWeights(matIndex, adjusted_simulation_strength);
}
}
private static void DescribeHumanJointsForFigure(ref HumanDescription description, DazFigurePlatform figure)
{
var map = GetJointMapForFigure(figure);
HumanBone[] humanBones = new HumanBone[HumanTrait.BoneName.Length];
int mapIdx = 0;
foreach (var humanBoneName in HumanTrait.BoneName)
{
if (map.ContainsKey(humanBoneName))
{
HumanBone humanBone = new HumanBone();
humanBone.humanName = humanBoneName;
humanBone.boneName = map[humanBoneName];
humanBone.limit.useDefaultValues = true; //todo get limits from dtu?
humanBones[mapIdx++] = humanBone;
}
}
description.human = humanBones;
}
private static Dictionary<string, string> GetJointMapForFigure(DazFigurePlatform figure)
{
Dictionary<string, string> map = new Dictionary<string, string>();
switch (figure)
{
case DazFigurePlatform.Genesis8:
case DazFigurePlatform.Genesis3:
ConfigureGenesisMapStandard(map);
break;
case DazFigurePlatform.Genesis2:
ConfigureGenesisMapStandard(map);//todo account for Gen2 variances
break;
case DazFigurePlatform.Victoria:
case DazFigurePlatform.Genesis:
case DazFigurePlatform.Michael:
case DazFigurePlatform.TheFreak:
case DazFigurePlatform.Victoria4:
case DazFigurePlatform.Victoria4Elite:
case DazFigurePlatform.Michael4:
case DazFigurePlatform.Michael4Elite:
case DazFigurePlatform.Stephanie4:
case DazFigurePlatform.Aiko4:
default:
//do nothing, let unity's excellent guesser handle it
break;
}
return map;
}
private static void ConfigureGenesisMapStandard(Dictionary<string, string> map)
{
//note: Genesis 3 finger bones have "Carpal#" parents
//Body/Body (Gen8)
map["Hips"] = "hip";
map["Spine"] = "abdomenUpper";
map["Chest"] = "chestLower";
map["UpperChest"] = "chestUpper";
//Body/Left Arm (Gen8)
map["LeftShoulder"] = "lCollar";
map["LeftUpperArm"] = "lShldrBend";
map["LeftLowerArm"] = "lForearmBend";
map["LeftHand"] = "lHand";
//Body/Right Arm (Gen8)
map["RightShoulder"] = "rCollar";
map["RightUpperArm"] = "rShldrBend";
map["RightLowerArm"] = "rForearmBend";
map["RightHand"] = "rHand";
//Body/Left Leg (Gen8)
map["LeftUpperLeg"] = "lThighBend";
map["LeftLowerLeg"] = "lShin";
map["LeftFoot"] = "lFoot";
map["LeftToes"] = "lToe";
//Body/Right Leg (Gen8)
map["RightUpperLeg"] = "rThighBend";
map["RightLowerLeg"] = "rShin";
map["RightFoot"] = "rFoot";
map["RightToes"] = "rToe";
//Head (Gen8)
map["Neck"] = "neckLower";
map["Head"] = "head";
map["LeftEye"] = "lEye";
map["RightEye"] = "rEye";
map["Jaw"] = "lowerJaw";
//Left Hand (Gen8)
map["Left Thumb Proximal"] = "lThumb1";
map["Left Thumb Intermediate"] = "lThumb2";
map["Left Thumb Distal"] = "lThumb3";
map["Left Index Proximal"] = "lIndex1";
map["Left Index Intermediate"] = "lIndex2";
map["Left Index Distal"] = "lIndex3";
map["Left Middle Proximal"] = "lMid1";
map["Left Middle Intermediate"] = "lMid2";
map["Left Middle Distal"] = "lMid3";
map["Left Ring Proximal"] = "lRing1";
map["Left Ring Intermediate"] = "lRing2";
map["Left Ring Distal"] = "lRing3";
map["Left Little Proximal"] = "lPinky1";
map["Left Little Intermediate"] = "lPinky2";
map["Left Little Distal"] = "lPinky3";
//Right Hand (Gen8)
map["Right Thumb Proximal"] = "rThumb1";
map["Right Thumb Intermediate"] = "rThumb2";
map["Right Thumb Distal"] = "rThumb3";
map["Right Index Proximal"] = "rIndex1";
map["Right Index Intermediate"] = "rIndex2";
map["Right Index Distal"] = "rIndex3";
map["Right Middle Proximal"] = "rMid1";
map["Right Middle Intermediate"] = "rMid2";
map["Right Middle Distal"] = "rMid3";
map["Right Ring Proximal"] = "rRing1";
map["Right Ring Intermediate"] = "rRing2";
map["Right Ring Distal"] = "rRing3";
map["Right Little Proximal"] = "rPinky1";
map["Right Little Intermediate"] = "rPinky2";
map["Right Little Distal"] = "rPinky3";
}
private void FixupStandardBasedMaterial(ref Material nuMat, GameObject fbxPrefab, string key/*, DTUData data*/)
{
////todo need fixup missing textures from the json
//Debug.LogWarning("dtuData has " + data.Materials.Count + " materials ");
//var modelPath = AssetDatabase.GetAssetPath(fbxPrefab);
//var nuTexturePath = Path.GetDirectoryName(modelPath);
//nuTexturePath = BuildUnityPath(nuTexturePath, fbxPrefab.name + "Textures___");
//nuTexturePath = AssetDatabase.GenerateUniqueAssetPath(nuTexturePath);
////walk data until find a material named with key
//foreach (var material in data.Materials)
//{
// if (material.MaterialName == key && false) //TODO hack to bypass unfinished fn
// {
// //walk properties and work on any with a texture path
// foreach (var property in material.Properties)
// {
// if (!string.IsNullOrEmpty(property.Texture))
// {
// //and the daz folder has that texture
// if (File.Exists(property.Texture))
// {
// //copy it into the local textures folder
// if (!Directory.Exists(nuTexturePath))
// Directory.CreateDirectory(nuTexturePath);
// var nuTextureName = BuildUnityPath(nuTexturePath, Path.GetFileName(property.Texture));
// //TODO-----------------------------
// //todo some diffuse maps are jpg with no alpha channel,
// //instead use the FBX's embedded/collected texture which already has alpha channel,
// //test whether that material already has a valid diffuse color texture
// //if so, reimport that with the importer options below
// //copy the texture file from the daz folder to nuTexturePath
// File.Copy(property.Texture, nuTextureName);
// TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(nuTextureName);
// if (importer != null)
// {
// //todo twiddle other switches here, before the reimport happens only once
// importer.alphaIsTransparency = KeyToTransparency(key);
// importer.alphaSource = KeyToAlphaSource(key);
// importer.convertToNormalmap = KeyToNormalMap(key);
// importer.heightmapScale = KeyToHeightmapScale(key);
// importer.normalmapFilter = KeyToNormalMapFilter(key);
// importer.wrapMode = KeyToWrapMode(key);
// importer.SaveAndReimport();
// }
// else
// {
// Debug.LogWarning("texture " + nuTextureName + " is not a project asset.");
// }
// }
// }
// }
// }
//}
}
private TextureImporterAlphaSource KeyToAlphaSource(string key)
{
throw new NotImplementedException();
}
private TextureWrapMode KeyToWrapMode(string key)
{
throw new NotImplementedException();
}
private TextureImporterNormalFilter KeyToNormalMapFilter(string key)
{
throw new NotImplementedException();
}
private float KeyToHeightmapScale(string key)
{
throw new NotImplementedException();
}
private bool KeyToNormalMap(string key)
{
throw new NotImplementedException();
}
private bool KeyToTransparency(string key)
{
throw new NotImplementedException();
}
//private void CustomizeMaterial(ref Material material, DazMaterialPropertiesInfo info)
//{
// material.SetColor("_BaseColor", info.BaseColor);
// material.SetFloat("_SurfaceType", info.Transparent ? 1 : 0); //0 == opaque, 1 == transparent
// Texture mainTexture = material.mainTexture;
// CustomizeTexture(ref mainTexture, info.Transparent);
// var normalMap = material.GetTexture("_NormalMap");
// if (!IsValidNormalMap(normalMap))
// material.SetTexture("_NormalMap", null);//nuke the invalid normal map, if its a mistake
// material.SetFloat("_Metallic", info.Metallic);
// material.SetFloat("_Smoothness", info.Smoothness);
// material.SetInt("_MaterialID", (int)info.MaterialType);
// material.SetFloat("_DoubleSidedEnable", info.DoubleSided ? 0 : 1);
//}
void CustomizeTexture(ref Texture texture, bool alphaIsTransparent)
{
if (texture != null)
{
var texPath = AssetDatabase.GetAssetPath(texture);
TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(texPath);
if (importer != null)
{
if (alphaIsTransparent && importer.DoesSourceTextureHaveAlpha())
{
importer.alphaIsTransparency = true;
}
//todo twiddle other switches here, before the reimport happens only once
importer.SaveAndReimport();
}
else
Debug.LogWarning("texture " + texture.name + " is not a project asset.");
}
else
Debug.LogWarning("null texture");
}
bool IsValidNormalMap(Texture normalMap)
{
if (normalMap == null)
return false;
var nmPath = AssetDatabase.GetAssetPath(normalMap);
TextureImporter importer = (TextureImporter)AssetImporter.GetAtPath(nmPath);
if (importer != null)
{
var settings = new TextureImporterSettings();
importer.ReadTextureSettings(settings);
return settings.textureType == TextureImporterType.NormalMap;
}
else
Debug.LogWarning("texture " + normalMap.name + " is not a project asset.");
return true;
}
// Validated menu item.
// Add a menu item named "Log Selected Transform Name" to MyMenu in the menu bar.
// We use a second function to validate the menu item
// so it will only be enabled if we have a transform selected.
[MenuItem("Assets/Daz3D/Create Unity Prefab", false, 101)]
static void DoStuffToSelectedDTU()
{
CreateDTUPrefab(Selection.activeObject);
if (Selection.activeTransform)
Debug.Log("Selected Transform is on " + Selection.activeTransform.gameObject.name + ".");
}
//// Validate the menu item defined by the function above.
//// The menu item will be disabled if this function returns false.
//[MenuItem("Assets/Daz3D/Create Unity Prefab", true)]
//static bool ValidateDTUSelected2()
//{
// return ValidateDTUSelected();
//}
private static void CreateDTUPrefab(UnityEngine.Object activeObject)
{
if (activeObject)
{
var dtuPath = AssetDatabase.GetAssetPath(activeObject);
var fbxPath = dtuPath.Replace(".dtu", ".fbx");
Import(dtuPath, fbxPath);
}
}
}
}