/** Load the KFB data for the selected animation, will return null if the animation does not exist in the KFB */
private byte[] getKFBData(int animToUse)
{
if (kfb == null)
{
return(null);
}
if (kfbfile == null)
{
if (this.adb.filenameExists(this.kfb))
{
kfbfile = NIFLoader.getNIF(this.kfb);
}
else
{
return(null);
}
//Debug.Log("getting KFB: " + this.kfb);
}
/** Choose the right animation to load from the KFB file. Ideally we should use the KFM to know what index to use */
for (int i = 0; i < kfbfile.numObjects; i += 4)
{
NiIntegerExtraData indexData = (NiIntegerExtraData)kfbfile.getObject(i);
NiIntegerExtraData sizeData = (NiIntegerExtraData)kfbfile.getObject(i + 1);
NiBinaryExtraData binData = (NiBinaryExtraData)kfbfile.getObject(i + 2);
NiBinaryExtraData binData2 = (NiBinaryExtraData)kfbfile.getObject(i + 3);
int animIdx = indexData.intExtraData;
if (animIdx == animToUse)
{
return(binData.getData());
}
}
//Debug.LogError("[" + this.kfb + "] can't find data for anim[" + animToUse + "]");
return(null);
}
private static void enqueSetTexture(Material mat, string propertyName, NIFFile nf, string texName)
{
NIFTexturePool.inst.addQueuedTextureAction(() =>
{
mat.SetTexture(propertyName, loadTexture1(nf, texName));
});
}
public static NIFFile getNIF(String fname, AssetDatabase.RequestCategory requestCategory = AssetDatabase.RequestCategory.NONE)
{
if (File.Exists(fname))
{
using (FileStream nifStream = new FileStream(fname, FileMode.Open))
{
NIFFile niffile = new NIFFile(nifStream);
prepTextures(niffile);
return(niffile);
}
}
lock (nifCache)
{
string key = fname + ":" + requestCategory.ToString();
NIFFile niffile;
if (!nifCache.TryGetValue(key, out niffile))
{
byte[] nifData = AssetDatabaseInst.DB.extractUsingFilename(fname, requestCategory);
using (MemoryStream nifStream = new MemoryStream(nifData))
{
niffile = new NIFFile(nifStream);
prepTextures(niffile);
nifCache[key] = niffile;
}
}
return(niffile);
}
}
public void setActiveAnimation(int anim)
{
//Debug.Log("set anim to " + anim);
nifanimation = loadKFB(anim);
this.activeAnimation = anim;
boneMap.Clear();
}
private GameObject loadNIFForSlot(GearSlot slot, GameObject skeleton, GameObject meshHolder, string nifFile, string geo)
{
//Debug.Log("load nif[" + nifFile + "] for slot " + slot, this.gameObject);
// First move all the meshes across to the skeleton
GameObject meshes = new GameObject(slot.ToString());
//Debug.Log("create new gameobh:" + meshes.name);
try
{
NIFFile file = NIFLoader.getNIF(nifFile);
GameObject newNifRoot = NIFLoader.loadNIF(file, nifFile, true);
meshes.transform.parent = meshHolder.transform;
//Debug.Log("Move components from loaded nif to our new gameobj");
foreach (SkinnedMeshRenderer r in newNifRoot.GetComponentsInChildren <SkinnedMeshRenderer>(true))
{
// Debug.Log("Move renderer " + r.gameObject.name);
r.transform.parent = meshes.transform;
}
/** I'm not quite sure how bows are supposed to work yet. The quiver, bow and prop all appear to be a single mesh, so they must be moved around using bones or something..
* At the moment they don't even show propertly because the ROOT bone assigned while loading is not copied over and is destroyed causing the SKinnedMeshRender to behave poorly
* More research required.
*/
// weapons are a bit different
if (!WardrobeStuff.isWeapon(slot))
{
// process the NiSkinningMeshModifier
NIFLoader.linkBonesToMesh(file, skeleton);
}
else
{
//Debug.Log("Treating slot (" + slot + ") as weapon and attach it to AP_r_hand on skeleton");
Transform t = skeleton.transform.FindDeepChild("AP_r_hand");
meshes.transform.parent = t;
meshes.transform.localPosition = new Vector3(0, 0, 0);
}
this.animationNif.clearBoneMap();
// disable the proxy geo
enableDisableGeo(nifFile, skeleton, false);
// special case to ensure boots are disabled as well
if (nifFile.Contains("foot"))
{
enableDisableGeo("boots", skeleton, false);
}
GameObject.DestroyObject(newNifRoot);
}
catch (Exception ex)
{
Debug.Log("Exception trying to load nif[" + nifFile + "]" + ex);
}
return(meshes);
}
static public GameObject loadNIFFromFile(String fname, bool skinMesh = false)
{
using (FileStream nifStream = new FileStream(fname, FileMode.Open, FileAccess.Read, FileShare.Read))
{
NIFFile nf = new NIFFile(nifStream);
prepTextures(nf);
return(loadNIF(nf, fname, skinMesh));
}
}
static public List <NiSkinningMeshModifier> getSkinMods(NIFFile nf)
{
List <NiSkinningMeshModifier> mods = new List <NiSkinningMeshModifier>();
foreach (NIFObject o in nf.getObjects())
{
if (o is NiSkinningMeshModifier)
{
mods.Add((NiSkinningMeshModifier)o);
}
}
return(mods);
}
public void setParams(AssetDatabase adb, string nif, string kfm, string kfb)
{
this.adb = adb;
this.nif = nif;
this.kfm = kfm;
this.kfb = kfb;
kfmfile = null;
kfbfile = null;
nifanimation = null;
activeAnimation = -1;
skeletonRoot = null;
anims = null;
boneMap.Clear();
}
static private NiMesh getMeshForMod(NIFFile nf, NiSkinningMeshModifier skinMod)
{
foreach (NIFObject o in nf.getObjects())
{
if (o is NiMesh)
{
if (((NiMesh)o).modLinks.Contains(skinMod.index))
{
return((NiMesh)o);
}
}
}
return(null);
}
static private NiFloatsExtraData getFloatsExtraData(NIFFile nf, NiMesh mesh, string v)
{
foreach (int eid in mesh.extraDataIDs)
{
NIFObject obj = nf.getObject(eid);
if (obj is NiFloatsExtraData)
{
NiFloatsExtraData fExtra = (NiFloatsExtraData)obj;
if (fExtra.extraDataString.Equals(v))
{
return(fExtra);
}
}
}
return(null);
}
static GameObject processNodeAndLinkToParent(NIFFile nf, NiNode niNode, GameObject parent, bool skinMesh)
{
GameObject goM = new GameObject();
goM.name = niNode.name;
foreach (NiMesh mesh in nf.getMeshes())
{
if (mesh.parentIndex == niNode.index)
{
GameObject meshGo = processMesh(nf, mesh, nf.getMeshData(mesh), skinMesh);
if (niNode is NiTerrainNode)
{
//meshGo.GetComponent<MeshRenderer>().material = new Material(Shader.Find("BasicTerrainShader"));
//Debug.Log("found a terrain node");
}
meshGo.transform.parent = goM.transform;
meshGo.transform.localScale = new Vector3(mesh.scale, mesh.scale, mesh.scale);
Quaternion q = GetRotation(toMat(mesh.matrix));
meshGo.transform.localRotation = q;
//meshGo.transform.localEulerAngles = new Vector3(mesh.ma)
}
}
nf.forEachChildNode(niNode.index, (obj) => processNodeAndLinkToParent(nf, obj, goM, skinMesh));
goM.transform.parent = parent.transform;
// Terrain NIFs already have their location set in the parent node, we don't need to set it for the mesh.
if (!(niNode is NiTerrainNode))
{
goM.transform.localPosition = new Vector3(niNode.translation.x, niNode.translation.y, niNode.translation.z);
Matrix4x4 mat = toMat(niNode.matrix);
Quaternion q = GetRotation(mat);
goM.transform.localRotation = q;
//Debug.Log("[" + niNode.name + "]: trans:\n" + mat.GetRow(0) + "\n" + mat.GetRow(1) + "\n" + mat.GetRow(2) + "\n" + mat.GetRow(3));
//goM.transform.localEulerAngles =
}
else
{
}
goM.transform.localScale = new Vector3(niNode.scale, niNode.scale, niNode.scale);
//goM.transform.localRotation
return(goM);
}
static public void linkBonesToMesh(NIFFile nf, GameObject skeletonRoot)
{
// Debug.Log("link bones to mesh[" + skeletonRoot.GetInstanceID() + "]");
List <NiSkinningMeshModifier> skinMods = getSkinMods(nf);
foreach (NiSkinningMeshModifier skinMod in skinMods)
{
if (skinMod != null)
{
List <Transform> bones = new List <Transform>();
List <Matrix4x4> bindPoses = new List <Matrix4x4>();
NIFObject rootBoneNode = nf.getObject(skinMod.rootBoneLinkID);
//Debug.Log("looking for root bone:" + rootBoneNode.name + " in skeleton root");
Transform rootBone = skeletonRoot.transform.FindDeepChild(rootBoneNode.name);
List <int> boneLinkIds = skinMod.boneLinkIDs;
for (int boneIdx = 0; boneIdx < boneLinkIds.Count; boneIdx++)
{
int objId = boneLinkIds[boneIdx];
NIFObject ni = nf.getObject(objId);
Transform t = skeletonRoot.transform.FindDeepChild(ni.name);
if (t != null)
{
bones.Add(t);
NITransform nit = skinMod.m_pkSkinToBoneTransforms[boneIdx];
Matrix4x4 m = toMat(nit.matrix).transpose;
bindPoses.Add(m);
}
}
NiMesh mes = getMeshForMod(nf, skinMod);
Transform meshObject = skeletonRoot.transform.FindDeepChild(mes.name);
SkinnedMeshRenderer meshRenderer = meshObject.GetComponent <SkinnedMeshRenderer>();
meshRenderer.updateWhenOffscreen = true;
//Debug.Log("found mesh renderer: " + meshRenderer.GetInstanceID() + " with bones:" + bones.Count);
meshRenderer.rootBone = rootBone;
meshRenderer.bones = bones.ToArray();
meshRenderer.sharedMesh.bindposes = bindPoses.ToArray();
meshRenderer.sharedMesh.RecalculateBounds();
}
}
}
// Use this for initialization
void Start()
{
AssetDatabase db = AssetDatabaseInst.DB;
KFMFile kfm = new KFMFile(new FileStream(@"C:\Users\Spikeles\Documents\NetBeansProjects\TelaraDBExplorer\TelaraDBEditorCore\human_female_medium.kfm", FileMode.Open, FileAccess.Read, FileShare.Read));
NIFFile kfbfile = new NIFFile(new FileStream(@"C:\Users\Spikeles\Documents\NetBeansProjects\TelaraDBExplorer\TelaraDBEditorCore\human_female_2h_shared.kfb", FileMode.Open, FileAccess.Read, FileShare.Read));
// 230, string -> index 2
List <KFAnimation> anims = kfm.kfanimations;
int maxAnimID = 0;
foreach (KFAnimation anim in anims)
{
maxAnimID = Mathf.Max(anim.id, maxAnimID);
//Debug.Log(anim.id + ":" + anim.sequenceFilename + ":" + anim.sequencename);
}
Debug.Log("maxAnimID:" + maxAnimID);
for (int i = 0; i < kfbfile.numObjects; i += 4)
{
NiIntegerExtraData indexData = (NiIntegerExtraData)kfbfile.getObject(i);
NiIntegerExtraData sizeData = (NiIntegerExtraData)kfbfile.getObject(i + 1);
NiBinaryExtraData binData = (NiBinaryExtraData)kfbfile.getObject(i + 2);
NiBinaryExtraData binData2 = (NiBinaryExtraData)kfbfile.getObject(i + 3);
KFAnimation anim = anims.DefaultIfEmpty(null).FirstOrDefault(a => a.id == indexData.intExtraData);
if (anim != null)
{
Debug.Log("kfb[" + indexData.intExtraData + "] match => [" + anim.id + "]" + anim.sequenceFilename);
}
else
{
Debug.Log("kfb[" + indexData.intExtraData + "] nomatch");
}
}
Debug.Log("kfb objs:" + kfbfile.numObjects / 4);
Debug.Log("anims:" + anims.Count);
//File.WriteAllBytes("human_female.kfb" + i + "_0", binData.getData());
//File.WriteAllBytes("human_female.kfb" + i + "_1", binData2.getData());
}
protected override void ThreadFunctionCDR()
{
// Do your threaded task. DON'T use the Unity API here
count++;
cacheWait[filename].WaitOne();
lock (originals)
{
// if our cache contains an object, return it immediately
if (originals.ContainsKey(filename))
{
return;
}
}
try
{
niffile = NIFLoader.getNIF(filename, parent.cat);
// extra check for terrain
if (filename.Contains("_terrain_"))
{
string lodname = filename.Replace("_split", "_lod_split");
try
{
lodfile = NIFLoader.getNIF(lodname, parent.cat);
}
catch (Exception ex)
{
Debug.Log("there was an exception while trying to load lod split:" + lodname + ": " + ex);
}
}
}
catch (Exception ex)
{
//Debug.Log("there was an exception while doing the thread:" + filename + ": " + ex);
}
}
static private Texture loadTexture1(NIFFile file, string name)
{
Texture tex = getCachedTObject(name);
if (tex != null)
{
return(tex);
}
lock (texDataCache)
{
if (texDataCache.ContainsKey(name))
{
tex = texDataCache[name].getTextureAndPurge();
}
}
if (tex == null)
{
try
{
byte[] data;
AssetDatabase db = AssetDatabaseInst.DB;
if (db == null)
{
//Debug.Log("db was null");
return(new Texture2D(2, 2));
}
data = db.extractUsingFilename(name, AssetDatabase.RequestCategory.TEXTURE);
tex = DDSLoader.DatabaseLoaderTexture_DDS.LoadDDS(data);
}
catch (Exception ex)
{
Debug.LogWarning("Unable to load texture:" + name + ":" + ex);
tex = new Texture2D(2, 2);
}
}
tex.name = name;
toriginals[name] = tex;
return(tex);
}
static private void prepTextures(NIFFile file)
{
for (int i = 0; i < file.getObjects().Count; i++)
{
NIFObject obj = file.getObjects()[i];
if (obj is NiSourceTexture)
{
NiSourceTexture tex = (NiSourceTexture)obj;
try
{
// preload texture
bool doLoad = false;
lock (NIFLoader.texDataCache)
{
if (!NIFLoader.texDataCache.ContainsKey(tex.texFilename))
{
doLoad = true;
}
}
if (doLoad)
{
byte[] data = AssetDatabaseInst.DB.extractUsingFilename(tex.texFilename, Assets.RiftAssets.AssetDatabase.RequestCategory.TEXTURE);
TextureData texData;
DDSLoader.DatabaseLoaderTexture_DDS.LoadDDS(data, out texData);
lock (NIFLoader.texDataCache)
{
if (!NIFLoader.texDataCache.ContainsKey(tex.texFilename))
{
NIFLoader.texDataCache.Add(tex.texFilename, texData);
}
}
}
}
catch (Exception ex)
{
}
}
}
}
static private String[] getTextureIds(NIFFile nf, NiMesh mesh)
{
String[] textureType;
NiTexturingProperty texturingProperty = mesh.getTexturingProperty(nf);
if (texturingProperty != null)
{
//Debug.Log("found texturing property for mesh " + mesh.name);
textureType = new String[texturingProperty.shaderMapList.Count];
foreach (int extraID in mesh.extraDataIDs)
{
NIFObject ni = nf.getObject(extraID);
if (ni is NiIntegerExtraData)
{
NiIntegerExtraData nied = (NiIntegerExtraData)ni;
if (nied.extraDataString != null)
{
if (nied.extraDataString.Contains("Texture"))
{
if (nied.intExtraData >= 0 && nied.intExtraData < textureType.Length)
{
textureType[nied.intExtraData] = nied.extraDataString;
}
else
{
// Debug.LogWarning("nied.intExtraData out of range:" + nied.intExtraData + " => " + textureType.Length);
}
}
}
}
}
}
else
{
textureType = new String[255];
}
return(textureType);
}
public static GameObject loadNIF(NIFFile nf, string fname, bool skinMesh = false, GameObject prefab = null)
{
GameObject root;
if (prefab != null)
{
root = prefab;
}
else
{
root = new GameObject();
}
root.name = Path.GetFileNameWithoutExtension(fname);
root.transform.localPosition = Vector3.zero;
nf.forEachChildNode(-1, (obj) => processNodeAndLinkToParent(nf, obj, root, skinMesh));
if (skinMesh)
{
linkBonesToMesh(nf, root);
}
return(root);
}
/// <summary>
/// This method needs to be called within an Update method from unity. As such, it should be pretty quick
/// </summary>
/// <param name="nf"></param>
/// <param name="mesh"></param>
/// <param name="meshData"></param>
/// <param name="skinMesh"></param>
/// <returns></returns>
static GameObject processMesh(NIFFile nf, NiMesh mesh, NIFFile.MeshData meshData, bool skinMesh)
{
//Debug.Log("process mesh:" + mesh.name);
GameObject go = new GameObject();
go.name = mesh.name;
if (mesh.name.Length == 0)
{
go.name = "mesh";
}
go.transform.localPosition = new Vector3(mesh.translation.x, mesh.translation.y, mesh.translation.z);
Mesh newMesh = new Mesh();
MeshFilter mf = go.AddComponent <MeshFilter>();
Renderer r;
if (!skinMesh)
{
r = go.AddComponent <MeshRenderer>();
}
else
{
r = go.AddComponent <SkinnedMeshRenderer>();
// needed to force Unity to use 2 bones. RIFT exposes 3 bones, and if we let Unity choose, it'll try to use 4
// which will make models look wrong
((SkinnedMeshRenderer)r).quality = SkinQuality.Bone2;
((SkinnedMeshRenderer)r).sharedMesh = newMesh;
}
mf.mesh = newMesh;
if (Assets.GameWorld.useColliders)
{
MeshCollider mc = go.AddComponent <MeshCollider>();
mc.sharedMesh = newMesh;
}
newMesh.subMeshCount = mesh.numSubMeshes;
if (mesh.meshPrimType != 0) // Triangles
{
Debug.Log("unknown meshPrimType:" + mesh.meshPrimType);
}
else
{
bool IS_TERRAIN = (nf.getStringTable().Contains("terrainL1"));
newMesh.SetVertices(meshData.verts);
if (meshData.inNormals.Count > 0)
{
newMesh.SetNormals(meshData.inNormals);
}
if (meshData.uvs.Count > 0)
{
newMesh.SetUVs(0, meshData.uvs);
}
if (meshData.boneWeights.Count > 0 && !IS_TERRAIN && skinMesh)
{
newMesh.boneWeights = meshData.boneWeights.ToArray();
}
// huge memory GC issue here....
newMesh.triangles = meshData.tristest;
r.material = doMaterials(nf, mesh, go);
}
return(go);
}
static Material doMaterials(NIFFile nf, NiMesh mesh, GameObject go)
{
StringBuilder strB = new StringBuilder(20);
if (standardShader == null)
{
standardShader = Shader.Find("Standard");
}
bool IS_TERRAIN = (nf.getStringTable().Contains("terrainL1"));
bool animated = false;
bool presetMaterial = false;
string materialName = null;
Material mat = null;
Material mat2 = null;
if (mesh.materialNames.Count > 0)
{
strB.Length = 0;
strB.Append("materials/");
strB.Append(mesh.materialNames[0]);
mat2 = Resources.Load <Material>(strB.ToString());
if (mat2 != null)
{
mat = Material.Instantiate <Material>(mat2);
}
}
else
{
Debug.LogWarning("No mesh materials found in mesh :" + mesh.name);
}
if (mat == null)
{
// do materials/textures
if (IS_TERRAIN)
{
materialName = "terrainmat";
}
if (mesh.materialNames.Contains("Ocean_Water_Shader") || mesh.materialNames.Contains("Flow_Water") || mesh.name.Contains("water_UP") || mesh.name.Contains("water_DOWN"))
{
materialName = "WaterMaterial";
}
bool alpha = (mesh.materialNames.Contains("TwoSided_Alpha_Specular") || mesh.materialNames.Contains("Lava_Flow_Decal"));
foreach (string n in mesh.materialNames)
{
if (n.ToLower().Contains("alpha"))
{
alpha = true;
}
}
if (alpha)
{
materialName = "2sidedtransmat_fade";
}
// handle some simple animated "scrolling" textures
animated = (mesh.materialNames.Contains("Additive_UVScroll_Distort") || mesh.materialNames.Contains("Lava_Flow_Decal") || mesh.materialNames.Contains("Local_Cloud_Flat") ||
mesh.materialNames.Contains("Alpha_UVScroll_Overlay_Foggy_Waterfall") || mesh.materialNames.Contains("Fat_spike12_m") || mesh.materialNames.Contains("pPlane1_m"));
if (animated)
{
materialName = "2sidedtransmat_fade";
}
foreach (int eid in mesh.extraDataIDs)
{
NIFObject obj = nf.getObject(eid);
if (obj is NiBooleanExtraData)
{
NiBooleanExtraData fExtra = (NiBooleanExtraData)obj;
switch (fExtra.extraDataString)
{
case "doAlphaTest":
if (fExtra.booleanData)
{
materialName = "2sidedtransmat";
}
break;
default:
break;
}
}
}
if (materialName == null)
{
if (standardMaterial == null)
{
standardMaterial = new Material(standardShader);
}
mat = Material.Instantiate(standardMaterial);
materialName = standardMaterial.name;
}
else
{
mat = Material.Instantiate(Resources.Load <Material>(materialName));
}
//Debug.Log("Using guessed material[" + materialName + "] for " + mesh.name + " from list of materials: " + string.Join(",", mesh.materialNames.ToArray()), go);
}
else if (mat2 != null)
{
materialName = mat2.name;
presetMaterial = true;
//Debug.Log("Using actual material[" + materialName + "] for " + mesh.name + " from list of materials: " + string.Join(",", mesh.materialNames.ToArray()), go);
}
else
{
Debug.LogWarning("No material found!?");
}
#if UNITY_EDITOR
MeshOriginalMaterial mom = go.AddComponent <MeshOriginalMaterial>();
if (mesh.materialNames.Count > 0)
{
mom.materialName = mesh.materialNames[0];
}
#endif
if (presetMaterial)
{
foreach (int extraId in mesh.extraDataIDs)
{
NIFObject obj = nf.getObject(extraId);
setMaterialProperty(mat, obj);
}
if (mat.HasProperty("doAlphaTest"))
{
if (mat.GetInt("doAlphaTest") == 0)
{
strB.Length = 0;
strB.Append("materials/");
strB.Append(mat2.name);
strB.Append("_shader_opaque");
string shaderName = strB.ToString();
//Debug.Log("loading opaque shader:" + shaderName, go);
Shader shader = Resources.Load <Shader>(shaderName);
if (shader != null)
{
mat.shader = shader;
}
}
}
}
mat.enableInstancing = true;
mat.EnableKeyword("_SPECULARHIGHLIGHTS_OFF");
if (animated)
{
NiFloatsExtraData extra = getFloatsExtraData(nf, mesh, "tex0ScrollRate");
if (extra != null)
{
UVScroll scroller = go.AddComponent <UVScroll>();
scroller.material = mat;
scroller.xRate = extra.floatData[0];
scroller.yRate = extra.floatData[1];
}
}
foreach (int eid in mesh.extraDataIDs)
{
NIFObject obj = nf.getObject(eid);
if (obj is NiFloatExtraData)
{
NiFloatExtraData fExtra = (NiFloatExtraData)obj;
switch (fExtra.extraDataString)
{
case "scaleY":
if (mat.HasProperty("_MainTex"))
{
mat.mainTextureScale = new Vector2(mat.mainTextureScale.x, fExtra.floatData);
}
else
{
if (mat.HasProperty("scaleY"))
{
mat.SetFloat("scaleY", fExtra.floatData);
}
else
{
Debug.LogWarning("While trying to set scaleY, material[" + mat.name + "][" + materialName + "] doesn't have an appropriate texture property");
}
}
break;
case "scale":
if (mat.HasProperty("_MainTex"))
{
mat.mainTextureScale = new Vector2(fExtra.floatData, mat.mainTextureScale.y);
}
else
{
if (mat.HasProperty("scale"))
{
mat.SetFloat("scale", fExtra.floatData);
}
else
{
Debug.LogWarning("While trying to set scale, material[" + mat.name + "][" + materialName + "] doesn't have an appropriate texture property");
}
}
break;
default:
break;
}
}
}
string[] textureNameIds = getTextureIds(nf, mesh);
if (presetMaterial)
{
foreach (int extraId in mesh.extraDataIDs)
{
NIFObject obj = nf.getObject(extraId);
setMaterialProperty(mat, obj);
}
}
if (mat.HasProperty("alphaTestRef"))
{
mat.SetFloat("alphaTestRef", 1.0f - mat.GetFloat("alphaTestRef"));
}
List <int> propIDs = mesh.nodePropertyIDs;
foreach (int propID in propIDs)
{
NIFObject obj = nf.getObject(propID);
if (obj is NiTexturingProperty)
{
NiTexturingProperty propObj = (NiTexturingProperty)obj;
foreach (NifTexMap tex in propObj.texList)
{
if (tex != null)
{
Debug.Log("\t" + tex.sourceTexLinkID);
}
}
int i = 0;
foreach (NifTexMap tex in propObj.shaderMapList)
{
string texName = "";
if (tex != null)
{
int sourceTexID = tex.sourceTexLinkID;
if (sourceTexID != -1)
{
NiSourceTexture sourceTex = (NiSourceTexture)nf.getObject(sourceTexID);
texName = sourceTex.texFilename;
if (presetMaterial)
{
strB.Length = 0;
if (IS_TERRAIN)
{
strB.Append("_terrain");
strB.Append(i);
}
else
{
strB.Append("_");
strB.Append(textureNameIds[i]);
}
// Debug.Log("attempt to set texture property :" + propertyName + " with texure:" + texName);
enqueSetTexture(mat, strB.ToString(), nf, texName);
//mat.SetTexture(propertyName, loadTexture(nf, texName));
}
else if (IS_TERRAIN)
{
strB.Length = 0;
strB.Append("_terrain");
strB.Append(i);
string param = strB.ToString();
//"_terrain" + i;
//Debug.Log("set " + param + " to " + texName + " mat:" + mat.name);
enqueSetTexture(mat, param, nf, texName);
//mat.SetTexture(param, loadTexture(nf, texName));
}
else
{
//Debug.Log("texName[" + texName + "]: id:" + textureNameIds[i]);
try
{
switch (textureNameIds[i])
{
case "skyGradientTexture0":
case "diffuseTexture":
case "diffuseTextureXZ":
enqueSetTexture(mat, "_MainTex", nf, texName);
//mat.SetTexture("_MainTex", loadTexture(nf, texName));
break;
case "decalNormalTexture":
enqueSetTexture(mat, "_DetailNormalMap", nf, texName);
//mat.SetTexture("_DetailNormalMap", loadTexture(nf, texName));
break;
case "normalTexture":
enqueSetTexture(mat, "_BumpMap", nf, texName);
//mat.SetTexture("_BumpMap", loadTexture(nf, texName));
break;
case "glowTexture":
mat.EnableKeyword("_EMISSION");
if (mesh.materialNames.Contains("Lava_Flow_Decal"))
{
mat.SetColor("_EmissionColor", Color.red);
}
else
{
mat.SetColor("_EmissionColor", Color.white * 0.5f);
}
enqueSetTexture(mat, "_EmissionMap", nf, texName);
//mat.SetTexture("_EmissionMap", loadTexture(nf, texName));
break;
case "glossTexture":
enqueSetTexture(mat, "_MetallicGlossMap", nf, texName);
//mat.SetTexture("_MetallicGlossMap", loadTexture(nf, texName));
break;
case "decalTexture":
case "starMapTexture0":
enqueSetTexture(mat, "_DetailAlbedoMap", nf, texName);
//mat.SetTexture("_DetailAlbedoMap", loadTexture(nf, texName));
break;
default:
//Debug.LogWarning("No shader material property for " + textureNameIds[i]);
break;
}
}catch (ArgumentOutOfRangeException ex)
{
Debug.LogWarning("Texture id[" + i + "] was out of range of the texture name ids: " + textureNameIds.ToList());
//mat.SetTexture("_MainTex", loadTexture(nf, texName));
enqueSetTexture(mat, "_MainTex", nf, texName);
}
}
}
}
i++;
}
}
}
return(mat);
}
private void updateRaceGender()
{
if (state != ClassState.UPDATE)
{
Debug.LogError("Cannot update race/gender without being update mode");
return;
}
if (refModel != null)
{
GameObject.Destroy(refModel);
}
if (costumeParts != null)
{
GameObject.Destroy(costumeParts);
}
// defines the base model
string nif = string.Format("{0}_refbare.nif", getBaseModel());
string kfm = string.Format("{0}.kfm", getBaseModel());
string kfb = string.Format("{0}.kfb", getKFBBase());
if (!"".Equals(kfbOverride))
{
kfb = kfbOverride;
}
animationNif = this.gameObject.GetComponent <AnimatedNif>();
if (animationNif == null)
{
animationNif = this.gameObject.AddComponent <AnimatedNif>();
}
animationNif.setParams(AssetDatabaseInst.DB, nif, kfm, kfb);
NIFFile file = NIFLoader.getNIF(nif);
GameObject go = NIFLoader.loadNIF(file, nif, true);
go.transform.parent = this.transform;
go.transform.localPosition = Vector3.zero;
go.transform.localRotation = Quaternion.identity;
refModel = go;
if (!"".Equals(animOverride))
{
animationNif.setActiveAnimation(animOverride);
}
else
{
string animation = string.Format("{0}_{1}_idle", getBaseModel(), getAnimationSet());
try
{
animationNif.setActiveAnimation(animation);
}
catch (Exception ex)
{
Debug.LogError("Unable to load animation:" + animation);
}
}
animationNif.setSkeletonRoot(refModel);
costumeParts = new GameObject("CostumeParts");
costumeParts.transform.parent = refModel.transform;
}
