public static void MapRenderTexToTexAnimIndex(Int32 texAnimIndex, Single textureWidth, Single textureHeight, SkinnedMeshRenderer skinnedMeshRenderer, Texture mainTexture, Dictionary <Int32, RenderTexture> renderTexMapping)
{
if (!renderTexMapping.ContainsKey(texAnimIndex))
{
RenderTexture renderTexture = new RenderTexture((Int32)textureWidth, (Int32)textureHeight, 24);
renderTexture.filterMode = FilterMode.Bilinear;
renderTexture.wrapMode = TextureWrapMode.Repeat;
renderTexture.name = skinnedMeshRenderer.transform.parent.name + "_" + skinnedMeshRenderer.name + "_RT";
skinnedMeshRenderer.material.mainTexture = renderTexture;
renderTexMapping.Add(texAnimIndex, renderTexture);
RenderTexture active = RenderTexture.active;
RenderTexture.active = renderTexture;
GL.PushMatrix();
GL.Clear(true, true, Color.clear);
GL.LoadPixelMatrix(0f, textureWidth, textureHeight, 0f);
Graphics.DrawTexture(new Rect(0f, 0f, textureWidth, textureHeight), mainTexture);
GL.PopMatrix();
RenderTexture.active = active;
}
}
public static void DrawMeshEdges(KrablMesh.MeshEdges mesh, Transform transform, float normalLength = 0.0f, SkinnedMeshRenderer smr = null)
{
int numVerts = mesh.vertCount();
int numEdges = mesh.edgeCount();
Vector3[] pts = new Vector3[numVerts];
Matrix4x4[] boneMatrices = null;
Matrix4x4 mat = new Matrix4x4();
bool useBones = (smr != null) && (mesh.hasBoneWeights);
if (useBones)
{
boneMatrices = BoneMatricesFromBonesAndBindposes(mesh.bindposes, smr.bones);
for (int i = 0; i < numVerts; ++i)
{
Vertex v = mesh.vertices[i];
DeformationMatrixForBoneWeight(v.boneWeight, boneMatrices, ref mat);
pts[i] = mat.MultiplyPoint3x4(v.coords);
}
}
else
{
for (int i = 0; i < numVerts; ++i)
{
Vertex v = mesh.vertices[i];
pts[i] = transform.TransformPoint(v.coords);
}
}
for (int i = 0; i < numEdges; ++i)
{
if (mesh.IsEdgeValid(i))
{
Edge e = mesh.edges[i];
Color col = Color.clear;
if (e.linkedFaces.Count <= 1)
{
col = Color.blue;
}
if (mesh.hasUV1 && mesh.IsEdgeUV1Seam(i))
{
col = Color.magenta;
}
if (e.crease > 0.0f)
{
col = Color.red;
}
if (col.a != 0.0f)
{
Gizmos.color = col;
Gizmos.DrawLine(pts[e.v[0]], pts[e.v[1]]);
}
}
}
if (normalLength > 0.0f)
{
Gizmos.color = Color.white;
int numFaces = mesh.faceCount();
if (useBones == false)
{
for (int i = 0; i < numFaces; ++i)
{
Face f = mesh.faces[i];
if (f.valid)
{
int[] vi = f.v;
for (int j = 0; j < f.cornerCount; ++j)
{
Vector3 n = f.vertexNormal[j];
n = transform.TransformDirection(n);
Vector3 p = pts[vi[j]];
Gizmos.DrawLine(p, p + n * normalLength);
}
}
}
}
else
{
for (int i = 0; i < numFaces; ++i)
{
Face f = mesh.faces[i];
if (f.valid)
{
int[] vi = f.v;
for (int j = 0; j < f.cornerCount; ++j)
{
int vindex = vi[j];
DeformationMatrixForBoneWeight(mesh.vertices[vindex].boneWeight, boneMatrices, ref mat);
Vector3 n = f.vertexNormal[j];
n = mat.MultiplyVector(n);
Vector3 p = pts[vindex];
Gizmos.DrawLine(p, p + n.normalized * normalLength);
}
}
}
}
}
}
private void OnBeginEffect(UnityEventArgs <FXArgs> e)
{
m_targetSmr = GetSmr(e.EventArgs.Target);
}
// Use this for initialization
void Start()
{
SkinnedMeshRenderer skinnedMeshRenderer = GetComponent <SkinnedMeshRenderer>(); // get the first Skinned mesh renderer component (only active ones!) in the objects children
skinnedMeshRenderer.material = mat;
}
private static void BuildNewMesh(SkinnedMeshRenderer skinnedMeshRenderer, Dictionary <int, int> newIndexLookUpDict,
Dictionary <int, int[]> subMeshes, BlendShapeLogic blendShapeLabel)
{
// get original mesh data
var materialList = new List <Material>();
skinnedMeshRenderer.GetSharedMaterials(materialList);
var mesh = skinnedMeshRenderer.sharedMesh;
var meshVertices = mesh.vertices;
var meshNormals = mesh.normals;
var meshTangents = mesh.tangents;
var meshColors = mesh.colors;
var meshBoneWeights = mesh.boneWeights;
var meshUVs = mesh.uv;
// build new mesh
var materialListNew = new List <Material>();
var newMesh = new Mesh();
if (mesh.vertexCount > ushort.MaxValue)
{
#if UNITY_2017_3_OR_NEWER
Debug.LogFormat("exceed 65535 vertices: {0}", mesh.vertexCount);
newMesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;
#else
throw new NotImplementedException(String.Format("exceed 65535 vertices: {0}", integrator.Positions.Count.ToString()));
#endif
}
var newDataLength = newIndexLookUpDict.Count;
var newIndexLookUp = newIndexLookUpDict.Keys.ToArray();
newMesh.vertices = newIndexLookUp.Select(x => meshVertices[x]).ToArray();
if (meshNormals.Length > 0)
{
newMesh.normals = newIndexLookUp.Select(x => meshNormals[x]).ToArray();
}
if (meshTangents.Length > 0)
{
newMesh.tangents = newIndexLookUp.Select(x => meshTangents[x]).ToArray();
}
if (meshColors.Length > 0)
{
newMesh.colors = newIndexLookUp.Select(x => meshColors[x]).ToArray();
}
if (meshBoneWeights.Length > 0)
{
newMesh.boneWeights = newIndexLookUp.Select(x => meshBoneWeights[x]).ToArray();
}
if (meshUVs.Length > 0)
{
newMesh.uv = newIndexLookUp.Select(x => meshUVs[x]).ToArray();
}
newMesh.bindposes = mesh.bindposes;
// add BlendShape data
if (blendShapeLabel == BlendShapeLogic.WithBlendShape)
{
for (int i = 0; i < mesh.blendShapeCount; i++)
{
// get original BlendShape data
var srcVertices = new Vector3[mesh.vertexCount];
var srcNormals = new Vector3[mesh.vertexCount];
var srcTangents = new Vector3[mesh.vertexCount];
mesh.GetBlendShapeFrameVertices(i, 0, srcVertices, srcNormals, srcTangents);
// declare the size for the destination array
var dstVertices = new Vector3[newDataLength];
var dstNormals = new Vector3[newDataLength];
var dstTangents = new Vector3[newDataLength];
dstVertices = newIndexLookUp.Select(x => srcVertices[x]).ToArray();
dstNormals = newIndexLookUp.Select(x => srcNormals[x]).ToArray();
dstTangents = newIndexLookUp.Select(x => srcTangents[x]).ToArray();
newMesh.AddBlendShapeFrame(mesh.GetBlendShapeName(i), mesh.GetBlendShapeFrameWeight(i, 0),
dstVertices, dstNormals, dstTangents);
}
}
newMesh.subMeshCount = subMeshes.Count;
var cosMaterialIndex = subMeshes.Keys.ToArray();
// build material list
for (int i = 0; i < subMeshes.Count; i++)
{
newMesh.SetTriangles(subMeshes[cosMaterialIndex[i]], i);
materialListNew.Add(materialList[cosMaterialIndex[i]]);
}
skinnedMeshRenderer.sharedMaterials = materialListNew.ToArray();
skinnedMeshRenderer.sharedMesh = newMesh;
// save mesh as asset
var assetPath = string.Format("{0}{1}", Path.GetFileNameWithoutExtension(mesh.name), ASSET_SUFFIX);
Debug.Log(assetPath);
if (!string.IsNullOrEmpty((AssetDatabase.GetAssetPath(mesh))))
{
var directory = Path.GetDirectoryName(AssetDatabase.GetAssetPath(mesh)).Replace("\\", "/");
assetPath = string.Format("{0}/{1}{2}", directory, Path.GetFileNameWithoutExtension(mesh.name) + "_" + blendShapeLabel.ToString(), ASSET_SUFFIX);
}
else
{
assetPath = string.Format("Assets/{0}{1}", Path.GetFileNameWithoutExtension(mesh.name) + "_" + blendShapeLabel.ToString(), ASSET_SUFFIX);
}
Debug.LogFormat("CreateAsset: {0}", assetPath);
AssetDatabase.CreateAsset(newMesh, assetPath);
}
void Start()
{
BlendShape = GetComponent <SkinnedMeshRenderer>();
}
void Start()
{
gameObject.AddComponent <Animation>();
gameObject.AddComponent <SkinnedMeshRenderer>();
SkinnedMeshRenderer renderer = GetComponent <SkinnedMeshRenderer>();
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[] {
new Vector3(-1, 0, 0), new Vector3(1, 0, 0), new Vector3(-1, 5, 0), new Vector3(1, 5, 0),
new Vector3(-1, 8, 0), new Vector3(1, 8, 0), new Vector3(-1, 13, 0), new Vector3(1, 13, 0)
};
mesh.uv = new Vector2[] {
new Vector2(0, 0), new Vector2(1, 0), new Vector2(0, 1), new Vector2(1, 1),
new Vector2(0, 0), new Vector2(1, 0), new Vector2(0, 1), new Vector2(1, 1)
};
mesh.triangles = new int[] {
0, 1, 2, 1, 3, 2,
4, 5, 6, 5, 7, 6
};
mesh.RecalculateNormals();
renderer.material = new Material(Shader.Find("Diffuse"));
BoneWeight[] weights = new BoneWeight[8] {
new BoneWeight()
{
boneIndex0 = 1, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 1, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 1, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 1, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 2, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 2, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 2, weight0 = 1
},
new BoneWeight()
{
boneIndex0 = 2, weight0 = 1
},
};
mesh.boneWeights = weights;
Transform[] bones = new Transform[3];
Matrix4x4[] bindPoses = new Matrix4x4[3];
bones[0] = new GameObject("Parent").transform;
bones[0].parent = transform;
bones[0].localRotation = Quaternion.identity;
bones[0].localPosition = Vector3.zero;
bindPoses[0] = bones[0].worldToLocalMatrix * transform.localToWorldMatrix;
bones[1] = new GameObject("Lower").transform;
bones[1].parent = bones[0];
bones[1].localRotation = Quaternion.identity;
bones[1].localPosition = Vector3.zero;
bindPoses[1] = bones[1].worldToLocalMatrix * bones[0].transform.localToWorldMatrix;
bones[2] = new GameObject("Upper").transform;
bones[2].parent = bones[0];
bones[2].localRotation = Quaternion.identity;
bones[2].localPosition = new Vector3(0, 5, 0);
bindPoses[2] = bones[2].worldToLocalMatrix * bones[0].transform.localToWorldMatrix;
mesh.bindposes = bindPoses;
renderer.bones = bones;
renderer.sharedMesh = mesh;
AnimationCurve curve = new AnimationCurve();
curve.keys = new Keyframe[] { new Keyframe(0, 0, 0, 0), new Keyframe(1, 3, 0, 0), new Keyframe(2, 0.0F, 0, 0) };
AnimationClip clip = new AnimationClip();
clip.SetCurve("Lower", typeof(Transform), "m_LocalPosition.z", curve);
animation.AddClip(clip, "test");
animation.Play("test");
}
public float UnsetMorphKeyframe(SkinnedMeshRenderer sMesh, bool asStart)
{
foreach (AnimationFrame frame in meshFrames)
{
Transform meshTransform = sMesh.m_GameObject.instance.FindLinkedComponent(UnityClassID.Transform);
if (frame.Name == meshTransform.GetTransformPath())
{
MorphMeshContainer morphMesh = frame.MeshContainer as MorphMeshContainer;
float tweenFactor = 0;
for (int meshObjIdx = 0; morphMesh != null; meshObjIdx++)
{
if (asStart)
{
if (morphMesh.StartBuffer != morphMesh.EndBuffer)
{
morphMesh.StartBuffer.Dispose();
morphMesh.StartBuffer = morphMesh.EndBuffer;
}
else
{
frame.MeshContainer = morphMesh.NextMeshContainer;
}
morphMesh.TweenFactor = 1.0f;
}
else
{
if (morphMesh.StartBuffer != morphMesh.EndBuffer)
{
morphMesh.EndBuffer.Dispose();
morphMesh.EndBuffer = morphMesh.StartBuffer;
}
else
{
frame.MeshContainer = morphMesh.NextMeshContainer;
}
morphMesh.TweenFactor = 0.0f;
}
tweenFactor = morphMesh.TweenFactor;
morphMesh = morphMesh.NextMeshContainer as MorphMeshContainer;
}
return tweenFactor;
}
}
Report.ReportLog("Mesh frame " + sMesh.m_GameObject.instance.m_Name + " not displayed.");
return -1f;
}
public SkinnedState(AmplifyMotionCamera owner, AmplifyMotionObjectBase obj)
: base(owner, obj)
{
m_renderer = m_obj.GetComponent <SkinnedMeshRenderer>();
}
void Awake()
{
_renderer = gameObject.GetComponent <SkinnedMeshRenderer>();
_executeSmoothing = new bool[_blendShapeNames.Length];
}
public IEnumerator Export(string path, Preset presetAsset, bool buildZip, bool exportPBRMaterials, bool exportAnimation = true, bool doConvertImages = false)
{
writer = new GlTF_Writer();
writer.Init();
done = false;
bool debugRightHandedScale = false;
GlTF_Writer.exportedFiles.Clear();
if (debugRightHandedScale)
{
GlTF_Writer.convertRightHanded = false;
}
writer.extraString.Add("exporterVersion", GlTF_Writer.exporterVersion);
Transform[] transforms0 = Selection.GetTransforms(SelectionMode.TopLevel);
//// Create rootNode
//GlTF_Node correctionNode = new GlTF_Node();
//correctionNode.id = GetInstanceID(transforms0[0]);
//correctionNode.name = transforms0[0].name;
//GlTF_Writer.nodes.Add(correctionNode);
//GlTF_Writer.nodeIDs.Add(correctionNode.id);
//GlTF_Writer.nodeNames.Add(correctionNode.name);
//GlTF_Writer.rootNodes.Add(correctionNode);
//path = toGlTFname(path);
savedPath = Path.GetDirectoryName(path);
// Temp list to keep track of skeletons
Dictionary <string, GlTF_Skin> parsedSkins = new Dictionary <string, GlTF_Skin>();
parsedSkins.Clear();
// first, collect objects in the scene, add to lists
Transform[] transforms = Selection.GetTransforms(SelectionMode.Deep);
List <Transform> trs = new List <Transform>(transforms);
// Prefilter selected nodes and look for skinning in order to list "bones" nodes
//FIXME: improve this
List <Transform> bones = new List <Transform>();
foreach (Transform tr in trs)
{
if (!tr.gameObject.activeSelf)
{
continue;
}
SkinnedMeshRenderer skin = tr.GetComponent <SkinnedMeshRenderer>();
if (skin)
{
foreach (Transform bone in skin.bones)
{
bones.Add(bone);
}
}
}
nbSelectedObjects = trs.Count;
int nbDisabledObjects = 0;
int nbIndex = 1;
foreach (Transform tr in trs)
{
if (tr.gameObject.activeInHierarchy == false)
{
nbDisabledObjects++;
continue;
}
// Initialize the node
GlTF_Node node = new GlTF_Node();
node.id = GetInstanceID(tr);//GlTF_Node.GetNameFromObject(tr);
node.name = GlTF_Writer.cleanNonAlphanumeric(tr.name);
if (tr.GetComponent <Camera>() != null)
{
parseUnityCamera(tr);
}
if (tr.GetComponent <Light>() != null)
{
parseUnityLight(tr);
}
Mesh m = GetMesh(tr);
if (m != null)
{
GlTF_Mesh mesh = new GlTF_Mesh();
mesh.id = GetInstanceID(m);
mesh.name = GlTF_Writer.cleanNonAlphanumeric(GlTF_Mesh.GetNameFromObject(m));
GlTF_Accessor positionAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "position"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
positionAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(positionAccessor);
GlTF_Accessor normalAccessor = null;
if (m.normals.Length > 0)
{
normalAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "normal"), GlTF_Accessor.Type.VEC3, GlTF_Accessor.ComponentType.FLOAT);
normalAccessor.bufferView = GlTF_Writer.vec3BufferView;
GlTF_Writer.accessors.Add(normalAccessor);
}
GlTF_Accessor colorAccessor = null;
if (m.colors.Length > 0)
{
colorAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "color"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
colorAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(colorAccessor);
}
GlTF_Accessor uv0Accessor = null;
if (m.uv.Length > 0)
{
uv0Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv0"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv0Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv0Accessor);
}
GlTF_Accessor uv1Accessor = null;
if (m.uv2.Length > 0)
{
// check if object is affected by a lightmap
uv1Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv1"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv1Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv1Accessor);
}
GlTF_Accessor uv2Accessor = null;
if (m.uv3.Length > 0)
{
uv2Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv2"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv2Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv2Accessor);
}
GlTF_Accessor uv3Accessor = null;
if (m.uv4.Length > 0)
{
uv3Accessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "uv3"), GlTF_Accessor.Type.VEC2, GlTF_Accessor.ComponentType.FLOAT);
uv3Accessor.bufferView = GlTF_Writer.vec2BufferView;
GlTF_Writer.accessors.Add(uv3Accessor);
}
GlTF_Accessor jointAccessor = null;
if (exportAnimation && m.boneWeights.Length > 0)
{
jointAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "joints"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.USHORT);
jointAccessor.bufferView = GlTF_Writer.vec4UshortBufferView;
GlTF_Writer.accessors.Add(jointAccessor);
}
GlTF_Accessor weightAccessor = null;
if (exportAnimation && m.boneWeights.Length > 0)
{
weightAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "weights"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
weightAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(weightAccessor);
}
GlTF_Accessor tangentAccessor = null;
if (m.tangents.Length > 0)
{
tangentAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "tangents"), GlTF_Accessor.Type.VEC4, GlTF_Accessor.ComponentType.FLOAT);
tangentAccessor.bufferView = GlTF_Writer.vec4BufferView;
GlTF_Writer.accessors.Add(tangentAccessor);
}
var smCount = m.subMeshCount;
for (var i = 0; i < smCount; ++i)
{
GlTF_Primitive primitive = new GlTF_Primitive();
primitive.name = GlTF_Primitive.GetNameFromObject(m, i);
primitive.index = i;
GlTF_Attributes attributes = new GlTF_Attributes();
attributes.positionAccessor = positionAccessor;
attributes.normalAccessor = normalAccessor;
attributes.colorAccessor = colorAccessor;
attributes.texCoord0Accessor = uv0Accessor;
attributes.texCoord1Accessor = uv1Accessor;
attributes.texCoord2Accessor = uv2Accessor;
attributes.texCoord3Accessor = uv3Accessor;
attributes.jointAccessor = jointAccessor;
attributes.weightAccessor = weightAccessor;
attributes.tangentAccessor = tangentAccessor;
primitive.attributes = attributes;
GlTF_Accessor indexAccessor = new GlTF_Accessor(GlTF_Accessor.GetNameFromObject(m, "indices_" + i), GlTF_Accessor.Type.SCALAR, GlTF_Accessor.ComponentType.USHORT);
indexAccessor.bufferView = GlTF_Writer.ushortBufferView;
GlTF_Writer.accessors.Add(indexAccessor);
primitive.indices = indexAccessor;
var mr = GetRenderer(tr);
var sm = mr.sharedMaterials;
if (i < sm.Length)
{
var mat = sm[i];
var matName = GlTF_Material.GetNameFromObject(mat);
if (GlTF_Writer.materialNames.Contains(matName))
{
primitive.materialIndex = GlTF_Writer.materialNames.IndexOf(matName); // THIS INDIRECTION CAN BE REMOVED!
}
else
{
GlTF_Material material = new GlTF_Material();
material.name = GlTF_Writer.cleanNonAlphanumeric(mat.name);
primitive.materialIndex = GlTF_Writer.materials.Count;
GlTF_Writer.materialNames.Add(matName);
GlTF_Writer.materials.Add(material);
//technique
var s = mat.shader;
var techName = GlTF_Technique.GetNameFromObject(s);
if (GlTF_Writer.techniqueNames.Contains(techName))
{
material.instanceTechniqueIndex = GlTF_Writer.techniqueNames.IndexOf(techName); // THIS INDIRECTION CAN BE REMOVED!
}
else
{
GlTF_Technique tech = new GlTF_Technique();
tech.name = techName;
GlTF_Technique.Parameter tParam = new GlTF_Technique.Parameter();
tParam.name = "position";
tParam.type = GlTF_Technique.Type.FLOAT_VEC3;
tParam.semantic = GlTF_Technique.Semantic.POSITION;
tech.parameters.Add(tParam);
GlTF_Technique.Attribute tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_position";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
if (normalAccessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "normal";
tParam.type = GlTF_Technique.Type.FLOAT_VEC3;
tParam.semantic = GlTF_Technique.Semantic.NORMAL;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_normal";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv0Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord0";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_0;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord0";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv1Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord1";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_1;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord1";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv2Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord2";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_2;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord2";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
if (uv3Accessor != null)
{
tParam = new GlTF_Technique.Parameter();
tParam.name = "texcoord3";
tParam.type = GlTF_Technique.Type.FLOAT_VEC2;
tParam.semantic = GlTF_Technique.Semantic.TEXCOORD_3;
tech.parameters.Add(tParam);
tAttr = new GlTF_Technique.Attribute();
tAttr.name = "a_texcoord3";
tAttr.param = tParam.name;
tech.attributes.Add(tAttr);
}
tech.AddDefaultUniforms();
// Populate technique with shader data
GlTF_Writer.techniqueNames.Add(techName);
GlTF_Writer.techniques.Add(tech);
// create program
GlTF_Program program = new GlTF_Program();
program.name = GlTF_Program.GetNameFromObject(s);
tech.program = program.name;
foreach (var attr in tech.attributes)
{
program.attributes.Add(attr.name);
}
GlTF_Writer.programs.Add(program);
}
unityToPBRMaterial(mat, ref material);
}
}
mesh.primitives.Add(primitive);
}
// If gameobject having SkinnedMeshRenderer component has been transformed,
// the mesh would need to be baked here.
mesh.Populate(m);
GlTF_Writer.meshes.Add(mesh);
node.meshIndex = GlTF_Writer.meshes.IndexOf(mesh);
}
// Parse animations
if (exportAnimation)
{
Animator a = tr.GetComponent <Animator>();
if (a != null)
{
AnimationClip[] clips = AnimationUtility.GetAnimationClips(tr.gameObject);
for (int i = 0; i < clips.Length; i++)
{
//FIXME It seems not good to generate one animation per animator.
GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(clips[i].name));
anim.Populate(clips[i], tr, GlTF_Writer.bakeAnimation);
if (anim.channels.Count > 0)
{
GlTF_Writer.animations.Add(anim);
}
}
}
Animation animation = tr.GetComponent <Animation>();
if (animation != null)
{
AnimationClip clip = animation.clip;
//FIXME It seems not good to generate one animation per animator.
GlTF_Animation anim = new GlTF_Animation(GlTF_Writer.cleanNonAlphanumeric(clip.name));
anim.Populate(clip, tr, GlTF_Writer.bakeAnimation);
if (anim.channels.Count > 0)
{
GlTF_Writer.animations.Add(anim);
}
}
}
// Parse transform
if (tr.parent == null)
{
Matrix4x4 mat = Matrix4x4.identity;
if (debugRightHandedScale)
{
mat.m22 = -1;
}
mat = mat * Matrix4x4.TRS(tr.localPosition, tr.localRotation, tr.localScale);
node.matrix = new GlTF_Matrix(mat);
}
// Use good transform if parent object is not in selection
else if (!trs.Contains(tr.parent))
{
node.hasParent = false;
Matrix4x4 mat = Matrix4x4.identity;
if (debugRightHandedScale)
{
mat.m22 = -1;
}
mat = mat * tr.localToWorldMatrix;
node.matrix = new GlTF_Matrix(mat);
}
else
{
node.hasParent = true;
if (tr.localPosition != Vector3.zero)
{
node.translation = new GlTF_Translation(tr.localPosition);
}
if (tr.localScale != Vector3.one)
{
node.scale = new GlTF_Scale(tr.localScale);
}
if (tr.localRotation != Quaternion.identity)
{
node.rotation = new GlTF_Rotation(tr.localRotation);
}
}
if (!node.hasParent)
{
// correctionNode.childrenNames.Add(node.name);
// correctionNode.childrenIDs.Add(node.id);
GlTF_Writer.rootNodes.Add(node);
}
if (tr.GetComponent <Camera>() != null)
{
node.cameraName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
}
else if (tr.GetComponent <Light>() != null)
{
node.lightName = GlTF_Writer.cleanNonAlphanumeric(tr.name);
}
// Parse node's skin data
GlTF_Accessor invBindMatrixAccessor = null;
SkinnedMeshRenderer skinMesh = tr.GetComponent <SkinnedMeshRenderer>();
if (exportAnimation && skinMesh != null && skinMesh.enabled && checkSkinValidity(skinMesh, trs) && skinMesh.rootBone != null)
{
GlTF_Skin skin = new GlTF_Skin();
skin.name = GlTF_Writer.cleanNonAlphanumeric(skinMesh.rootBone.name);// + "_skeleton_" + GlTF_Writer.cleanNonAlphanumeric(node.name) + tr.GetInstanceID();
// Create invBindMatrices accessor
invBindMatrixAccessor = new GlTF_Accessor(skin.name + "invBindMatrices", GlTF_Accessor.Type.MAT4, GlTF_Accessor.ComponentType.FLOAT);
invBindMatrixAccessor.bufferView = GlTF_Writer.mat4BufferView;
GlTF_Writer.accessors.Add(invBindMatrixAccessor);
// Generate skin data
skin.Populate(tr, ref invBindMatrixAccessor, GlTF_Writer.accessors.Count - 1);
GlTF_Writer.skins.Add(skin);
node.skinIndex = GlTF_Writer.skins.IndexOf(skin);
}
foreach (Transform t in tr.transform)
{
if (t.gameObject.activeInHierarchy)
{
node.childrenNames.Add(GlTF_Node.GetNameFromObject(t));
node.childrenIDs.Add(GlTF_Node.GetIDFromObject(t));
}
}
GlTF_Writer.nodeNames.Add(node.name);
GlTF_Writer.nodeIDs.Add(node.id);
GlTF_Writer.nodes.Add(node);
// Debug.Log(node.name + "_" + node.id + "_" + nbIndex++);
}
if (GlTF_Writer.meshes.Count == 0)
{
Debug.Log("No visible objects have been exported. Aboring export");
yield return(false);
}
writer.OpenFiles(path);
writer.Write();
writer.CloseFiles();
if (nbDisabledObjects > 0)
{
Debug.Log(nbDisabledObjects + " disabled object ignored during export");
}
Debug.Log("Scene has been exported to " + path);
EditorUtility.DisplayDialog("状态", "导出成功", "Ok");
done = true;
yield return(true);
}
public void TagSet(string tag)
{
switch (tag)
{
case "Player 1":
SkinnedMeshRenderer renderer = GetComponent <SkinnedMeshRenderer>();
if (renderer == null)
{
GetComponent <MeshRenderer>().materials = new Material[2] {
player1, player1Second
};
}
else
{
renderer.materials = new Material[2] {
player1, player1Second
};
}
break;
case "Player 2":
SkinnedMeshRenderer renderer1 = GetComponent <SkinnedMeshRenderer>();
if (renderer1 == null)
{
GetComponent <MeshRenderer>().materials = new Material[2] {
player2, player2Second
};
}
else
{
renderer1.materials = new Material[2] {
player2, player2Second
};
}
break;
case "Player 3":
SkinnedMeshRenderer renderer2 = GetComponent <SkinnedMeshRenderer>();
if (renderer2 == null)
{
GetComponent <MeshRenderer>().materials = new Material[2] {
player3, player3Second
};
}
else
{
renderer2.materials = new Material[2] {
player3, player3Second
};
}
break;
case "Player 4":
SkinnedMeshRenderer renderer3 = GetComponent <SkinnedMeshRenderer>();
if (renderer3 == null)
{
GetComponent <MeshRenderer>().materials = new Material[2] {
player4, player4Second
};
}
else
{
renderer3.materials = new Material[2] {
player4, player4Second
};
}
break;
}
}
//合成角色的自构方法
//参数：序列号/骨架名/武器名/头部名/胸部名/手部名/脚步名/是否合成材质
//这里的部件名使用的是Prefab文件全名 调用时需在外部根据命名规则处理Prefab文件全名
public UCharacterController(int index, string skeleton, string weapon,
string head, string chest, string hand, string feet, bool combine = false)
{
//设置合成角色参数
this.index = index;
this.skeleton = skeleton;
this.equipment_head = head;
this.equipment_chest = chest;
this.equipment_hand = hand;
this.equipment_feet = feet;
//实例化骨架
Object res = Resources.Load("Sekia/Prefab/" + skeleton);
this.Instance = GameObject.Instantiate(res) as GameObject;
//实例化所有部件 收集网格和材质
string[] equipments = new string[4];
equipments [0] = head;
equipments [1] = chest;
equipments [2] = hand;
equipments [3] = feet;
SkinnedMeshRenderer[] meshes = new SkinnedMeshRenderer[4];
GameObject[] objects = new GameObject[4];
for (int i = 0; i < equipments.Length; i++)
{
res = Resources.Load("Sekia/Prefab/" + equipments [i]);
objects[i] = GameObject.Instantiate(res) as GameObject;
meshes[i] = objects[i].GetComponentInChildren <SkinnedMeshRenderer> ();
}
//合成所有网格和材质到骨架 建议直接作为全局静态方法使用
App.Game.CharacterMgr.CombineSkinnedMgr.CombineObject(Instance, meshes, combine);
//删除临时实例化的GameObject
for (int i = 0; i < objects.Length; i++)
{
GameObject.DestroyImmediate(objects [i].gameObject);
}
//实例化武器
res = Resources.Load("Sekia/Prefab/" + weapon);
WeaponInstance = GameObject.Instantiate(res) as GameObject;
//将武器挂载到武器根目录 根据骨骼命名规则找武器根目录
Transform[] transforms = Instance.GetComponentsInChildren <Transform>();
foreach (Transform joint in transforms)
{
if (joint.name == "weapon_hand_r")
{
WeaponInstance.transform.parent = joint.gameObject.transform;
break;
}
}
//初始化武器实例状态
WeaponInstance.transform.localScale = Vector3.one;
WeaponInstance.transform.localPosition = Vector3.zero;
WeaponInstance.transform.localRotation = Quaternion.identity;
//播放动画 这里播放老版本Legacy动画才使用的Animation组件
//使用Mecanim动画系统的应使用Animator组件和动画控制器
animationController = Instance.GetComponent <Animation>();
PlayStand();
}
public static void Export(string dirPath, Animator parser, SkinnedMeshRenderer morphObj)
{
DirectoryInfo dir = new DirectoryInfo(dirPath);
ExporterMorph exporter = new ExporterMorph(dir, parser, morphObj);
exporter.Export(dir);
}
protected override void PrepareWearable(GameObject assetContainer)
{
Animation animation = null;
//NOTE(Brian): Fix to support hierarchy difference between AssetBundle and GLTF wearables.
Utils.ForwardTransformChildTraversal <Transform>((x) =>
{
if (x.name.Contains("Armature"))
{
var armatureGO = x.parent;
animation = armatureGO.gameObject.GetOrCreateComponent <Animation>();
armatureGO.gameObject.GetOrCreateComponent <StickerAnimationListener>();
return(false); //NOTE(Brian): If we return false the traversal is stopped.
}
return(true);
},
assetContainer.transform);
animation.cullingType = AnimationCullingType.BasedOnRenderers;
//We create a mock SkinnedMeshRenderer to hold the bones for the animations,
//since any of the others SkinnedMeshRenderers in the bodyshape can be disabled arbitrarily
SkinnedMeshRenderer[] skinnedMeshRenderersInChild = assetContainer.GetComponentsInChildren <SkinnedMeshRenderer>();
skinnedMeshRenderer = animation.gameObject.GetOrCreateComponent <SkinnedMeshRenderer>();
skinnedMeshRenderer.enabled = true;
foreach (SkinnedMeshRenderer meshRenderer in skinnedMeshRenderersInChild)
{
if (skinnedMeshRenderer != meshRenderer)
{
skinnedMeshRenderer.rootBone = meshRenderer.rootBone;
skinnedMeshRenderer.bones = meshRenderer.bones;
break;
}
}
var animator = animationTarget.GetComponent <AvatarAnimatorLegacy>();
animator.BindBodyShape(animation, bodyShapeId, animationTarget);
var allRenderers = assetContainer.GetComponentsInChildren <SkinnedMeshRenderer>(true);
foreach (var r in allRenderers)
{
string parentName = r.transform.parent.name.ToLower();
if (parentName.Contains("ubody"))
{
upperBodyRenderer = r;
}
else if (parentName.Contains("lbody"))
{
lowerBodyRenderer = r;
}
else if (parentName.Contains("feet"))
{
feetRenderer = r;
}
else if (parentName.Contains("head"))
{
headRenderer = r;
}
else if (parentName.Contains("eyebrows"))
{
eyebrowsRenderer = r;
}
else if (parentName.Contains("eyes"))
{
eyesRenderer = r;
}
else if (parentName.Contains("mouth"))
{
mouthRenderer = r;
}
}
}
public float SetMorphKeyframe(SkinnedMeshRenderer sMesh, int keyframeIdx, bool asStart)
{
foreach (AnimationFrame frame in meshFrames)
{
Transform meshTransform = sMesh.m_GameObject.instance.FindLinkedComponent(UnityClassID.Transform);
if (frame.Name == meshTransform.GetTransformPath())
{
Mesh mesh = Operations.GetMesh(sMesh);
AnimationMeshContainer animMesh = frame.MeshContainer as AnimationMeshContainer;
if (animMesh != null)
{
MorphMeshContainer[] morphMeshes = new MorphMeshContainer[mesh.m_SubMeshes.Count];
int startVertexIdx = 0;
for (int meshObjIdx = 0; meshObjIdx < mesh.m_SubMeshes.Count; meshObjIdx++)
{
MorphMeshContainer morphMesh = new MorphMeshContainer();
morphMeshes[meshObjIdx] = morphMesh;
morphMesh.FaceCount = (int)mesh.m_SubMeshes[meshObjIdx].indexCount / 3;
morphMesh.IndexBuffer = animMesh.MeshData.Mesh.IndexBuffer;
morphMesh.VertexCount = (int)mesh.m_SubMeshes[meshObjIdx].vertexCount;
Operations.vMesh vMesh = new Operations.vMesh(sMesh, false, false);
List<Operations.vVertex> vertexList = vMesh.submeshes[meshObjIdx].vertexList;
VertexBuffer vertBuffer = CreateMorphVertexBuffer(mesh.m_Shapes, keyframeIdx, vertexList, startVertexIdx);
morphMesh.StartBuffer = morphMesh.EndBuffer = vertBuffer;
int vertBufferSize = morphMesh.VertexCount * Marshal.SizeOf(typeof(TweeningWithoutNormalsVertexBufferFormat.Stream2));
vertBuffer = new VertexBuffer(device, vertBufferSize, Usage.WriteOnly, VertexFormat.Texture1, Pool.Managed);
using (DataStream vertexStream = vertBuffer.Lock(0, vertBufferSize, LockFlags.None))
{
for (int i = 0; i < vertexList.Count; i++)
{
Operations.vVertex vertex = vertexList[i];
vertexStream.Write(vertex.uv[0]);
vertexStream.Write(vertex.uv[1]);
}
vertBuffer.Unlock();
}
morphMesh.CommonBuffer = vertBuffer;
morphMesh.MaterialIndex = animMesh.MaterialIndex;
morphMesh.TextureIndex = animMesh.TextureIndex;
morphMesh.TweenFactor = 0.0f;
startVertexIdx += morphMesh.VertexCount;
animMesh = (AnimationMeshContainer)animMesh.NextMeshContainer;
}
for (int meshObjIdx = 0; meshObjIdx < mesh.m_SubMeshes.Count; meshObjIdx++)
{
morphMeshes[meshObjIdx].NextMeshContainer = meshObjIdx < mesh.m_SubMeshes.Count - 1
? (MeshContainer)morphMeshes[meshObjIdx + 1] : frame.MeshContainer;
}
frame.MeshContainer = morphMeshes[0];
return 0;
}
else
{
MorphMeshContainer morphMesh = frame.MeshContainer as MorphMeshContainer;
Operations.vMesh vMesh = new Operations.vMesh(sMesh, false, false);
int startVertexIdx = 0;
for (int meshObjIdx = 0; meshObjIdx < mesh.m_SubMeshes.Count; meshObjIdx++)
{
List<Operations.vVertex> vertexList = vMesh.submeshes[meshObjIdx].vertexList;
VertexBuffer vertBuffer = CreateMorphVertexBuffer(mesh.m_Shapes, keyframeIdx, vertexList, startVertexIdx);
if (asStart)
{
if (morphMesh.StartBuffer != morphMesh.EndBuffer)
{
morphMesh.StartBuffer.Dispose();
}
morphMesh.StartBuffer = vertBuffer;
morphMesh.TweenFactor = 0.0f;
}
else
{
if (morphMesh.StartBuffer != morphMesh.EndBuffer)
{
morphMesh.EndBuffer.Dispose();
}
morphMesh.EndBuffer = vertBuffer;
morphMesh.TweenFactor = 1.0f;
}
startVertexIdx += morphMesh.VertexCount;
morphMesh = morphMesh.NextMeshContainer as MorphMeshContainer;
}
return asStart ? 0 : 1;
}
}
}
Report.ReportLog("Mesh frame " + sMesh.m_GameObject.instance.m_Name + " not displayed.");
return -1f;
}
void DoUpdate()
{
if (source == null || WrapEnabled == false || target == null || source.bindverts == null) //|| bindposes == null )
{
return;
}
if (targetIsSkin && source.neededVerts != null && source.neededVerts.Count > 0)
{
if (source.boneweights == null)
{
SkinnedMeshRenderer tmesh = (SkinnedMeshRenderer)target.GetComponent(typeof(SkinnedMeshRenderer));
if (tmesh != null)
{
if (!sourceIsSkin)
{
Mesh sm = tmesh.sharedMesh;
bindposes = sm.bindposes;
source.boneweights = sm.boneWeights;
}
}
}
for (int i = 0; i < source.neededVerts.Count; i++)
{
skinnedVerts[source.neededVerts[i]] = GetSkinPos(source, source.neededVerts[i]);
}
}
Vector3 p = Vector3.zero;
if (targetIsSkin && !sourceIsSkin)
{
for (int i = 0; i < source.bindverts.Length; i++)
{
if (source.bindverts[i].verts.Count > 0)
{
p = Vector3.zero;
for (int j = 0; j < source.bindverts[i].verts.Count; j++)
{
MegaBindInf bi = source.bindverts[i].verts[j];
Vector3 p0 = skinnedVerts[bi.i0];
Vector3 p1 = skinnedVerts[bi.i1];
Vector3 p2 = skinnedVerts[bi.i2];
Vector3 cp = GetCoordMine(p0, p1, p2, bi.bary);
Vector3 norm = FaceNormal(p0, p1, p2);
cp += ((bi.dist * shrink) + gap) * norm.normalized;
p += cp * (bi.weight / source.bindverts[i].weight);
}
verts[i] = transform.InverseTransformPoint(p) + offset;
}
}
}
else
{
for (int i = 0; i < source.bindverts.Length; i++)
{
if (source.bindverts[i].verts.Count > 0)
{
p = Vector3.zero;
for (int j = 0; j < source.bindverts[i].verts.Count; j++)
{
MegaBindInf bi = source.bindverts[i].verts[j];
Vector3 p0 = target.sverts[bi.i0];
Vector3 p1 = target.sverts[bi.i1];
Vector3 p2 = target.sverts[bi.i2];
Vector3 cp = GetCoordMine(p0, p1, p2, bi.bary);
Vector3 norm = FaceNormal(p0, p1, p2);
cp += ((bi.dist * shrink) + gap) * norm.normalized;
p += cp * (bi.weight / source.bindverts[i].weight);
}
}
else
{
p = source.freeverts[i]; //startverts[i];
}
p = target.transform.TransformPoint(p);
verts[i] = transform.InverseTransformPoint(p) + offset;
}
}
mesh.vertices = verts;
RecalcNormals();
mesh.RecalculateBounds();
}
void Awake()
{
this.meshRendered = GetComponent <SkinnedMeshRenderer>();
Assert.IsNotNull(this.meshRendered);
this.sharedMesh = this.meshRendered.sharedMesh;
}
public void SpawnNPC(NPCAction action, bool isRandom, bool isMale)
{
//If there is a premium requirement in the NPCAction, set it, if not, 1 in X chance of being a premium NPC
bool premium;
if (action.reqs.ContainsKey(2))
{
if (action.reqs[2].Equals("t"))
{
premium = true;
}
else
{
premium = false;
}
}
else
{
premium = (Random.Range(0, 4) == 0 ? true : false);
}
// Create an NPC from Prefab and locate the bones we'll need for attatching objects and such
Debug.Log(spawner.position);
GameObject newNPC = Instantiate(Resources.Load <GameObject>(isMale ? "NPC/MALE_NPC" : "NPC/FEMALE_NPC"), spawner.position, spawner.rotation);
// If NPC is random, they have no ID
if (isRandom)
{
newNPC.name = "NPC_RAND_" + 0;
}
else
{
newNPC.name = "NPC_" + action.id.ToString();
}
Transform root = newNPC.transform.Find("Squ_People3:root");
Transform rootHead = root.transform.Find("Squ_People3:pelvis").transform.Find("Squ_People3:spine_01")
.transform.Find("Squ_People3:spine_02").transform.Find("Squ_People3:spine_03").transform.Find("Squ_People3:neck_01")
.transform.Find("Squ_People3:head");
Transform body = newNPC.transform.Find(isMale ? "male_01_body" : "female_01_body");
// Set skintone for body and head
Texture skintone = skintones[Random.Range(0, skintones.Length)];
body.GetComponent <SkinnedMeshRenderer>().material.mainTexture = skintone;
newNPC.transform.Find("head_01").GetComponent <SkinnedMeshRenderer>().material.mainTexture = skintone;
// Shirt generation
int shirtValToUse = Random.Range(0, (isMale ? maleShirts.Length : femaleShirts.Length));
Mesh shirtMesh = (isMale ? maleShirts[shirtValToUse] : femaleShirts[shirtValToUse]);
Material shirtMat = (premium ? combinedShirtColors[Random.Range(0, combinedShirtColors.Length)] : shirtColors[Random.Range(0, shirtColors.Length)]);
// Find the shirt bones and create the shirt object
Transform shirt = newNPC.transform.Find(shirtMesh.name);
GameObject newShirt = new GameObject();
newShirt.transform.SetParent(newNPC.transform);
SkinnedMeshRenderer newShirt_smr = newShirt.AddComponent <SkinnedMeshRenderer>();
newShirt_smr.sharedMesh = shirtMesh;
newShirt_smr.rootBone = root;
newShirt_smr.bones = shirt.GetComponent <SkinnedMeshRenderer>().bones;
newShirt_smr.material = shirtMat;
// If interior shirt, make the exterior shirt
if ((isMale && shirtValToUse == 4) || (!isMale && shirtValToUse == 7))
{
// Second shirt generation
Mesh shirtMesh2 = Resources.Load <Mesh>(isMale ? "NPC/Meshes/male_ext_shirt" : "NPC/Meshes/female_ext_shirt");
Material shirtMat2 = (premium ? combinedShirtColors[Random.Range(0, combinedShirtColors.Length)] : shirtColors[Random.Range(0, shirtColors.Length)]);
Transform shirt2 = newNPC.transform.Find(isMale ? "male_01_shirt5_twoLayer_Exterior" : "female_01_shirt5_twoLayer_Exterior");
GameObject newShirt2 = new GameObject();
newShirt2.transform.SetParent(newNPC.transform);
SkinnedMeshRenderer newShirt2_smr = newShirt2.AddComponent <SkinnedMeshRenderer>();
newShirt2_smr.sharedMesh = shirtMesh2;
newShirt2_smr.rootBone = root;
newShirt2_smr.bones = shirt2.GetComponent <SkinnedMeshRenderer>().bones;
newShirt2_smr.material = shirtMat2;
}
Texture pantText = pantColors[Random.Range(0, pantColors.Length)];
// Pants Generation
// No pants for female NPCs wearing dresses (0, 1, 2) or a swimsuit (8)
if (isMale || (shirtValToUse != 0 && shirtValToUse != 1 && shirtValToUse != 2 && shirtValToUse != 8))
{
int pantValToUse = Random.Range(0, (isMale ? malePants.Length : femalePants.Length));
Mesh pantsMesh = (isMale ? malePants[pantValToUse] : femalePants[pantValToUse]);
Transform pants = newNPC.transform.Find(pantsMesh.name);
GameObject newPants = new GameObject();
newPants.transform.SetParent(newNPC.transform);
SkinnedMeshRenderer newPants_smr = newPants.AddComponent <SkinnedMeshRenderer>();
newPants_smr.sharedMesh = pantsMesh;
newPants_smr.rootBone = root;
newPants_smr.bones = pants.GetComponent <SkinnedMeshRenderer>().bones;
newPants_smr.material.mainTexture = pantText;
}
// Belt
// No pants for female NPCs wearing dresses (0, 1, 2) or a swimsuit (8)
if (isMale || (shirtValToUse != 0 && shirtValToUse != 1 && shirtValToUse != 2 && shirtValToUse != 8))
{
if (Random.Range(0, 2) == 0)
{
Mesh beltMesh = Resources.Load <Mesh>(isMale ? "NPC/Meshes/male_belt" : "NPC/Meshes/female_belt");
Transform belt = newNPC.transform.Find(isMale ? "male_01_belt" : "female_01_belt");
GameObject newBelt = new GameObject();
newBelt.transform.SetParent(newNPC.transform);
SkinnedMeshRenderer newBelt_smr = newBelt.AddComponent <SkinnedMeshRenderer>();
newBelt_smr.sharedMesh = beltMesh;
newBelt_smr.rootBone = root;
newBelt_smr.bones = belt.GetComponent <SkinnedMeshRenderer>().bones;
newBelt_smr.material.mainTexture = pantText;
}
}
// Eyes
Transform eyes = rootHead.transform.Find("Squ_People3:eyesAndTeeth");
Texture eyeTexture = eyeColors[Random.Range(0, eyeColors.Length)];
eyes.GetComponent <MeshRenderer>().material.mainTexture = eyeTexture;
// Hair
int hairValToUse = Random.Range(-1, hairs.Length);
/*if (action.reqs.ContainsKey(2))
* {
* hairValToUse = int.Parse(action.reqs[2]);
* }*/
int hairColorVal = (premium ? Random.Range(0, combinedHairColors.Length) : Random.Range(0, hairColors.Length));
// If hairValToUse is -1, npc is bald, don't bother giving them hair
if (hairValToUse != -1)
{
Mesh hairMesh = hairs[hairValToUse];
Material hairMat = (premium ? combinedHairColors[hairColorVal] : hairColors[hairColorVal]);
GameObject hair = new GameObject();
hair.transform.SetParent(rootHead.transform);
MeshRenderer hair_mr = hair.AddComponent <MeshRenderer>();
MeshFilter hair_mf = hair.AddComponent <MeshFilter>();
hair_mf.mesh = hairMesh;
hair_mr.material = hairMat;
hair.transform.localScale = hairScales[hairValToUse];
hair.transform.localPosition = Vector3.zero;
hair.transform.localRotation = newNPC.transform.rotation;
Vector3 hairRot = hair.transform.localRotation.eulerAngles;
hairRot = new Vector3(hairRot.x + 1.321f, hairRot.y - 90, hairRot.z);
hair.transform.localRotation = Quaternion.Euler(hairRot);
}
// Eyebrows
Mesh eyebrowMesh = eyebrowMeshes[Random.Range(0, eyebrowMeshes.Length)];
Material eyebrowMat = (premium ? combinedHairColors[hairColorVal] : hairColors[hairColorVal]);
GameObject eyebrows = new GameObject();
eyebrows.transform.SetParent(rootHead.transform);
MeshRenderer eyebrows_mr = eyebrows.AddComponent <MeshRenderer>();
MeshFilter eyebrows_mf = eyebrows.AddComponent <MeshFilter>();
eyebrows_mf.mesh = eyebrowMesh;
eyebrows_mr.material = eyebrowMat;
eyebrows.transform.localPosition = Vector3.zero;
eyebrows.transform.localRotation = newNPC.transform.rotation;
Vector3 eyebrowRot = eyebrows.transform.localRotation.eulerAngles;
eyebrowRot = new Vector3(eyebrowRot.x + 1.321f, eyebrowRot.y - 90, eyebrowRot.z);
eyebrows.transform.localRotation = Quaternion.Euler(eyebrowRot);
// Glasses
// TODO: system for weighting mask much less
// TODO: glasses color list
if (Random.Range(0, 4) == 0)
{
Mesh glassesMesh = glassesMeshes[Random.Range(0, glassesMeshes.Length)];
Material glassesMat = hairColors[Random.Range(0, hairColors.Length)];
GameObject glasses = new GameObject();
glasses.transform.SetParent(rootHead.transform);
MeshRenderer glasses_mr = glasses.AddComponent <MeshRenderer>();
MeshFilter glasses_mf = glasses.AddComponent <MeshFilter>();
glasses_mf.mesh = glassesMesh;
glasses_mr.material = glassesMat;
glasses.transform.localScale = glassesScale;
glasses.transform.localPosition = Vector3.zero;
glasses.transform.localRotation = newNPC.transform.rotation;
Vector3 glassesRot = glasses.transform.localRotation.eulerAngles;
glassesRot = new Vector3(glassesRot.x + 1.321f, glassesRot.y - 90, glassesRot.z);
glasses.transform.localRotation = Quaternion.Euler(glassesRot);
}
// Things that are specific to only Male NPCs
if (isMale)
{
// Beard
if (Random.Range(0, 2) == 0)
{
Mesh beardMesh = beardMeshes[Random.Range(0, beardMeshes.Length)];
GameObject beard = new GameObject();
beard.transform.SetParent(rootHead.transform);
MeshRenderer beard_mr = beard.AddComponent <MeshRenderer>();
MeshFilter beard_mf = beard.AddComponent <MeshFilter>();
beard_mf.mesh = beardMesh;
beard_mr.material = (premium ? combinedHairColors[hairColorVal] : hairColors[hairColorVal]);
beard.transform.localPosition = Vector3.zero;
beard.transform.localRotation = newNPC.transform.rotation;
Vector3 beardRot = beard.transform.localRotation.eulerAngles;
beardRot = new Vector3(beardRot.x + 1.321f, beardRot.y - 90, beardRot.z);
beard.transform.localRotation = Quaternion.Euler(beardRot);
}
// Destroy all the placeholder gameobjects
GameObject.Destroy(newNPC.transform.Find("male_01_belt").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_pants1_long").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_pants2_shorts").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_pants3_kilt").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt1_long").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt2_tee").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt3_muscle").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt4_suit").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt5_twoLayer_Exterior").gameObject);
GameObject.Destroy(newNPC.transform.Find("male_01_shirt5_twoLayer_Interior").gameObject);
}
// Things that are specific to only Female NPCs
else
{
// Makeup
// TODO: allow multiple makeups at one
if (Random.Range(0, 2) == 0)
{
GameObject makeup = new GameObject();
makeup.transform.SetParent(rootHead.transform);
MeshRenderer makeup_mr = makeup.AddComponent <MeshRenderer>();
MeshFilter makeup_mf = makeup.AddComponent <MeshFilter>();
Mesh makeupMesh = makeups[Random.Range(0, makeups.Length)];
Material makeupMat = makeupColors[Random.Range(0, makeupColors.Length)];
makeup_mf.mesh = makeupMesh;
makeup_mr.material = makeupMat;
makeup.transform.localScale = glassesScale;
makeup.transform.localPosition = Vector3.zero;
makeup.transform.localRotation = newNPC.transform.rotation;
Vector3 makeupRot = makeup.transform.localRotation.eulerAngles;
makeupRot = new Vector3(makeupRot.x + 1.321f, makeupRot.y - 90, makeupRot.z);
makeup.transform.localRotation = Quaternion.Euler(makeupRot);
}
// Destroy all the placeholder gameobjects
GameObject.Destroy(newNPC.transform.Find("female_01_belt").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_pants1_long").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_pants2_shorts").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_pants3_skirt").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_pants3_longSkirt").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_dress1").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_dress2").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_dress3").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt1_long").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt2_tee").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt3_muscle").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt4_suit").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt5_twoLayer_Exterior").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_shirt5_twoLayer_Interior").gameObject);
GameObject.Destroy(newNPC.transform.Find("female_01_swimsuit").gameObject);
}
// Set manager steps
NPCManager manager = newNPC.GetComponent <NPCManager>();
manager.isRandom = isRandom;
string userName = "";
if (action.reqs.ContainsKey(0))
{
userName = action.reqs[0];
}
else
{
var testy = randomUsernames.Where(w => w.genStatus == 0);
var usernameGen = testy.ElementAt(Random.Range(0, testy.Count()));
userName = usernameGen.username;
xmlParser.UpdateUsername(userName);
}
// Update npc count
numNPCs++;
manager.SetUp(action, userName);
}
private static void SeparatePolyWithBlendShape(SkinnedMeshRenderer skinnedMeshRendererInput)
{
var indicesUsedByBlendShape = new Dictionary <int, int>();
var mesh = skinnedMeshRendererInput.sharedMesh;
// retrieve the original BlendShape data
for (int i = 0; i < mesh.blendShapeCount; ++i)
{
var deltaVertices = new Vector3[mesh.vertexCount];
var deltaNormals = new Vector3[mesh.vertexCount];
var deltaTangents = new Vector3[mesh.vertexCount];
mesh.GetBlendShapeFrameVertices(i, 0, deltaVertices, deltaNormals, deltaTangents);
for (int j = 0; j < deltaVertices.Length; j++)
{
if (!deltaVertices[j].Equals(ZERO_MOVEMENT))
{
if (!indicesUsedByBlendShape.Values.Contains(j))
{
indicesUsedByBlendShape.Add(indicesUsedByBlendShape.Count, j);
}
}
}
}
var subMeshCount = mesh.subMeshCount;
var submeshesWithBlendShape = new Dictionary <int, int[]>();
var submeshesWithoutBlendShape = new Dictionary <int, int[]>();
var vertexIndexWithBlendShape = new Dictionary <int, int>();
var vertexCounterWithBlendShape = 0;
var vertexIndexWithoutBlendShape = new Dictionary <int, int>();
var vertexCounterWithoutBlendShape = 0;
// check blendshape's vertex index from submesh
for (int i = 0; i < subMeshCount; i++)
{
var triangle = mesh.GetTriangles(i);
var submeshWithBlendShape = new List <int>();
var submeshWithoutBlendShape = new List <int>();
for (int j = 0; j < triangle.Length; j += 3)
{
if (indicesUsedByBlendShape.Values.Contains(triangle[j]) ||
indicesUsedByBlendShape.Values.Contains(triangle[j + 1]) ||
indicesUsedByBlendShape.Values.Contains(triangle[j + 2]))
{
BuildNewTriangleList(vertexIndexWithBlendShape, triangle, j, submeshWithBlendShape, ref vertexCounterWithBlendShape);
}
else
{
BuildNewTriangleList(vertexIndexWithoutBlendShape, triangle, j, submeshWithoutBlendShape, ref vertexCounterWithoutBlendShape);
}
}
if (submeshWithBlendShape.Count > 0)
{
submeshesWithBlendShape.Add(i, submeshWithBlendShape.ToArray());
}
if (submeshWithoutBlendShape.Count > 0)
{
submeshesWithoutBlendShape.Add(i, submeshWithoutBlendShape.ToArray());
}
;
}
// check if any BlendShape exists
if (submeshesWithoutBlendShape.Count > 0)
{
// put the mesh without BlendShape in a new SkinnedMeshRenderer
var srcGameObject = skinnedMeshRendererInput.gameObject;
var srcTransform = skinnedMeshRendererInput.transform.parent;
var targetObjectForMeshWithoutBS = GameObject.Instantiate(srcGameObject);
targetObjectForMeshWithoutBS.name = srcGameObject.name + "_WithoutBlendShape";
targetObjectForMeshWithoutBS.transform.SetParent(srcTransform);
var skinnedMeshRendererWithoutBS = targetObjectForMeshWithoutBS.GetComponent <SkinnedMeshRenderer>();
// build meshes with/without BlendShape
BuildNewMesh(skinnedMeshRendererInput, vertexIndexWithBlendShape, submeshesWithBlendShape, BlendShapeLogic.WithBlendShape);
BuildNewMesh(skinnedMeshRendererWithoutBS, vertexIndexWithoutBlendShape, submeshesWithoutBlendShape, BlendShapeLogic.WithoutBlendShape);
}
}
public static void SetupSkinnedMeshRenderer(SkinnedMeshRenderer smr)
{
smr.rootBone = FindRootBone(smr.gameObject);
smr.bones = FindBones(smr.rootBone);
}
/**
* Save any modifications to the z_EditableObject. If the mesh is a scene mesh or imported mesh, it
* will be saved to a new asset. If the mesh was originally an asset mesh, the asset is overwritten.
* \return true if save was successful, false if user-canceled or otherwise failed.
*/
public static bool SaveMeshAsset(Mesh mesh, MeshFilter meshFilter = null, SkinnedMeshRenderer skinnedMeshRenderer = null)
{
string save_path = DO_NOT_SAVE;
string guid = null;
z_ModelSource source = GetMeshGUID(mesh, ref guid);
switch (source)
{
case z_ModelSource.Asset:
int saveChanges = EditorUtility.DisplayDialogComplex(
"Save Changes",
"Save changes to edited mesh?",
"Save", // DIALOG_OK
"Cancel", // DIALOG_CANCEL
"Save As"); // DIALOG_ALT
if (saveChanges == DIALOG_OK)
{
save_path = AssetDatabase.GetAssetPath(mesh);
}
else if (saveChanges == DIALOG_ALT)
{
save_path = EditorUtility.SaveFilePanelInProject("Save Mesh As", mesh.name + ".asset", "asset", "Save edited mesh to");
}
else
{
return(false);
}
break;
case z_ModelSource.Imported:
case z_ModelSource.Scene:
default:
// @todo make sure path is in Assets/
save_path = EditorUtility.SaveFilePanelInProject("Save Mesh As", mesh.name + ".asset", "asset", "Save edited mesh to");
break;
}
if (!save_path.Equals(DO_NOT_SAVE) && !string.IsNullOrEmpty(save_path))
{
Object existing = AssetDatabase.LoadMainAssetAtPath(save_path);
if (existing != null && existing is Mesh)
{
// save over an existing mesh asset
z_MeshUtility.Copy((Mesh)existing, mesh);
GameObject.DestroyImmediate(mesh);
}
else
{
AssetDatabase.CreateAsset(mesh, save_path);
}
AssetDatabase.Refresh();
if (meshFilter != null)
{
meshFilter.sharedMesh = (Mesh)AssetDatabase.LoadAssetAtPath(save_path, typeof(Mesh));
}
else if (skinnedMeshRenderer != null)
{
skinnedMeshRenderer.sharedMesh = (Mesh)AssetDatabase.LoadAssetAtPath(save_path, typeof(Mesh));
}
return(true);
}
// Save was canceled
return(false);
}
private void AddSkinnedMesh(Assimp.Node node, GameObject parent, Material[] mats, CombineInstance[] combine)
{
SkinnedMeshRenderer meshRenderer = parent.AddComponent <SkinnedMeshRenderer>();
List <List <Assimp.Bone> > meshBones = new List <List <Assimp.Bone> >();
Dictionary <int, List <BoneWeight1> > VertexBonesWeights = new Dictionary <int, List <BoneWeight1> >();
List <Transform[]> bonesArray = new List <Transform[]>();
List <Matrix4x4[]> bindPoses = new List <Matrix4x4[]>();
//Debug.Log(node.Name + " / " + parent.name);
int previousVertexCount = 0;
for (int iMesh = 0; iMesh < node.MeshIndices.Count; iMesh++)
{
Assimp.Mesh currentMesh = scene.Meshes[node.MeshIndices[iMesh]];
meshBones.Add(currentMesh.Bones);
bonesArray.Add(new Transform[currentMesh.BoneCount]);
bindPoses.Add(new Matrix4x4[currentMesh.BoneCount]);
for (int iBone = 0; iBone < bonesArray[iMesh].Length; iBone++)
{
Assimp.Bone currentBones = meshBones[iMesh][iBone];
if (!bones.ContainsKey(currentBones.Name))
{
Debug.Log("missing bone " + currentBones.Name);
continue;
}
bonesArray[iMesh][iBone] = bones[currentBones.Name];
bindPoses[iMesh][iBone] = bonesArray[iMesh][iBone].worldToLocalMatrix;
for (int iVertex = 0; iVertex < currentBones.VertexWeightCount; iVertex++)
{
int vertexIndex = currentBones.VertexWeights[iVertex].VertexID + previousVertexCount;
float weight = currentBones.VertexWeights[iVertex].Weight;
BoneWeight1 boneWeight = new BoneWeight1()
{
boneIndex = iBone, weight = weight
};
if (!VertexBonesWeights.ContainsKey(vertexIndex))
{
VertexBonesWeights.Add(vertexIndex, new List <BoneWeight1>());
}
VertexBonesWeights[vertexIndex].Add(boneWeight);
}
}
previousVertexCount += currentMesh.VertexCount;
}
List <Assimp.Bone> meshBonesFlat = new List <Assimp.Bone>();
meshBones.ForEach(x => meshBonesFlat.AddRange(x));
List <Transform> bonesArrayFlat = new List <Transform>();
bonesArray.ForEach(x => bonesArrayFlat.AddRange(x));
List <Matrix4x4> bindPosesFlat = new List <Matrix4x4>();
bindPoses.ForEach(x => bindPosesFlat.AddRange(x));
List <BoneWeight> bonesWeightsFlat = new List <BoneWeight>();
byte[] bonesPerVertes = new byte[VertexBonesWeights.Count];
List <BoneWeight1> bw = new List <BoneWeight1>();
for (int i = 0; i < VertexBonesWeights.Count; i++)
{
bonesPerVertes[i] = (byte)VertexBonesWeights[i].Count;
VertexBonesWeights[i].Sort((x, y) =>
{
if (x == null)
{
if (y == null)
{
return(0);
}
else
{
return(-1);
}
}
else
{
if (y == null)
{
return(1);
}
else
{
return(-x.weight.CompareTo(y.weight));
}
}
});
bw.AddRange(VertexBonesWeights[i]);
}
meshRenderer.bones = bonesArrayFlat.ToArray();
meshRenderer.sharedMesh = new Mesh();
meshRenderer.sharedMesh.bindposes = bindPosesFlat.ToArray();
meshRenderer.sharedMesh.CombineMeshes(combine, false);
meshRenderer.sharedMesh.SetBoneWeights(new NativeArray <byte>(bonesPerVertes, Allocator.Temp), new NativeArray <BoneWeight1>(bw.ToArray(), Allocator.Temp));
meshRenderer.sharedMesh.name = meshes[node.MeshIndices[0]].name;
meshRenderer.sharedMaterials = mats;
meshRenderer.rootBone = rootBone;
if (meshRenderer.sharedMesh.bounds.size.magnitude > meshSize.magnitude)
{
meshCenter = meshRenderer.bounds.center;
meshSize = meshRenderer.bounds.size;
bodyMesh = meshRenderer;
}
}
// Start is called before the first frame update
void Start()
{
SkinnedMeshRenderer = GetComponent<SkinnedMeshRenderer>();
animator = GetComponent<Animator>();
}
public void OnPreRender()
{
if (commandBuffer == null)
{
return;
}
CreateMaterialsIfNeeded();
if (renderTexture == null || renderTexture.width != sourceCamera.pixelWidth || renderTexture.height != sourceCamera.pixelHeight)
{
renderTexture = new RenderTexture(sourceCamera.pixelWidth, sourceCamera.pixelHeight, 16, RenderTextureFormat.Default);
extraRenderTexture = new RenderTexture(sourceCamera.pixelWidth, sourceCamera.pixelHeight, 16, RenderTextureFormat.Default);
outlineCamera.targetTexture = renderTexture;
}
UpdateMaterialsPublicProperties();
UpdateOutlineCameraFromSource();
outlineCamera.targetTexture = renderTexture;
commandBuffer.SetRenderTarget(renderTexture);
commandBuffer.Clear();
if (outlines != null)
{
foreach (Outline outline in outlines)
{
LayerMask l = sourceCamera.cullingMask;
if (outline != null && l == (l | (1 << outline.originalLayer)))
{
for (int v = 0; v < outline.Renderer.sharedMaterials.Length; v++)
{
Material m = null;
if (outline.Renderer.sharedMaterials[v].mainTexture != null && outline.Renderer.sharedMaterials[v])
{
foreach (Material g in materialBuffer)
{
if (g.mainTexture == outline.Renderer.sharedMaterials[v].mainTexture)
{
if (outline.eraseRenderer && g.color == outlineEraseMaterial.color)
{
m = g;
}
else if (g.color == GetMaterialFromID(outline.color).color)
{
m = g;
}
}
}
if (m == null)
{
if (outline.eraseRenderer)
{
m = new Material(outlineEraseMaterial);
}
else
{
m = new Material(GetMaterialFromID(outline.color));
}
m.mainTexture = outline.Renderer.sharedMaterials[v].mainTexture;
materialBuffer.Add(m);
}
}
else
{
if (outline.eraseRenderer)
{
m = outlineEraseMaterial;
}
else
{
m = GetMaterialFromID(outline.color);
}
}
if (backfaceCulling)
{
m.SetInt("_Culling", (int)UnityEngine.Rendering.CullMode.Back);
}
else
{
m.SetInt("_Culling", (int)UnityEngine.Rendering.CullMode.Off);
}
commandBuffer.DrawRenderer(outline.GetComponent <Renderer>(), m, 0, 0);
MeshFilter mL = outline.GetComponent <MeshFilter>();
if (mL)
{
for (int i = 1; i < mL.sharedMesh.subMeshCount; i++)
{
commandBuffer.DrawRenderer(outline.GetComponent <Renderer>(), m, i, 0);
}
}
SkinnedMeshRenderer sMR = outline.GetComponent <SkinnedMeshRenderer>();
if (sMR)
{
for (int i = 1; i < sMR.sharedMesh.subMeshCount; i++)
{
commandBuffer.DrawRenderer(outline.GetComponent <Renderer>(), m, i, 0);
}
}
}
}
}
}
outlineCamera.Render();
}
internal override void InitializeSkins()
{
GameObject model = bodyPrefab.GetComponentInChildren <ModelLocator>().modelTransform.gameObject;
CharacterModel characterModel = model.GetComponent <CharacterModel>();
ModelSkinController skinController = model.AddComponent <ModelSkinController>();
ChildLocator childLocator = model.GetComponent <ChildLocator>();
SkinnedMeshRenderer mainRenderer = characterModel.mainSkinnedMeshRenderer;
CharacterModel.RendererInfo[] defaultRenderers = characterModel.baseRendererInfos;
List <SkinDef> skins = new List <SkinDef>();
#region DefaultSkin
SkinDef defaultSkin = Modules.Skins.CreateSkinDef(PlayableTemplarPlugin.developerPrefix + "_PLAYABLETEMPLAR_BODY_DEFAULT_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMainSkin"),
defaultRenderers,
mainRenderer,
model);
defaultSkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenrySword"),
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenryGun"),
renderer = defaultRenderers[1].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenry"),
renderer = defaultRenderers[instance.mainRendererIndex].renderer
}
};
skins.Add(defaultSkin);
#endregion
#region MasterySkin
Material masteryMat = Modules.Assets.CreateMaterial("matHenryAlt");
CharacterModel.RendererInfo[] masteryRendererInfos = SkinRendererInfos(defaultRenderers, new Material[]
{
masteryMat,
masteryMat
});
SkinDef masterySkin = Modules.Skins.CreateSkinDef(PlayableTemplarPlugin.developerPrefix + "_PLAYABLETEMPLAR_BODY_MASTERY_SKIN_NAME",
Assets.mainAssetBundle.LoadAsset <Sprite>("texMasteryAchievement"),
masteryRendererInfos,
mainRenderer,
model,
masterySkinUnlockableDef);
masterySkin.meshReplacements = new SkinDef.MeshReplacement[]
{
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenrySwordAlt"),
renderer = defaultRenderers[0].renderer
},
new SkinDef.MeshReplacement
{
mesh = Modules.Assets.mainAssetBundle.LoadAsset <Mesh>("meshHenryAlt"),
renderer = defaultRenderers[instance.mainRendererIndex].renderer
}
};
skins.Add(masterySkin);
#endregion
skinController.skins = skins.ToArray();
}
// Use this for initialization
void Start()
{
render = GetComponentInChildren <SkinnedMeshRenderer>();
anim = GetComponent <Animator>();
rb = GetComponent <Rigidbody>();
}
void Start()
{
Animation[] animations = GetComponentsInChildren <Animation>();
foreach (Animation animation in animations)
{
animation.cullingType = AnimationCullingType.AlwaysAnimate;
}
SkinnedMeshRenderer[] smRenderers = GetComponentsInChildren <SkinnedMeshRenderer>();
List <Transform> bones = new List <Transform>();
List <BoneWeight> boneWeights = new List <BoneWeight>();
List <CombineInstance> combineInstances = new List <CombineInstance>();
Dictionary <Transform, Matrix4x4> ts = new Dictionary <Transform, Matrix4x4>();
int boneOffset = 0;
for (int s = 0; s < smRenderers.Length; s++)
{
SkinnedMeshRenderer smr = smRenderers[s];
BoneWeight[] meshBoneweight = smr.sharedMesh.boneWeights;
foreach (BoneWeight bw in meshBoneweight)
{
BoneWeight bWeight = bw;
bWeight.boneIndex0 += boneOffset;
bWeight.boneIndex1 += boneOffset;
bWeight.boneIndex2 += boneOffset;
bWeight.boneIndex3 += boneOffset;
boneWeights.Add(bWeight);
}
boneOffset += smr.bones.Length;
Transform[] meshBones = smr.bones;
int meshBoneIndex = 0;
foreach (Transform bone in meshBones)
{
bones.Add(bone);
ts.Add(bone, smr.sharedMesh.bindposes[meshBoneIndex] * smr.worldToLocalMatrix);
++meshBoneIndex;
}
CombineInstance ci = new CombineInstance();
ci.mesh = smr.sharedMesh;
ci.transform = smr.transform.localToWorldMatrix;
combineInstances.Add(ci);
Object.Destroy(smr.gameObject);
}
List <Matrix4x4> bindposes = new List <Matrix4x4>();
for (int b = 0; b < bones.Count; b++)
{
//bindposes.Add(bones[b].worldToLocalMatrix * transform.worldToLocalMatrix);
//bindposes.Add(bones[b].worldToLocalMatrix);
bindposes.Add(ts[bones[b]]);
}
SkinnedMeshRenderer r = gameObject.AddComponent <SkinnedMeshRenderer>();
r.sharedMesh = new Mesh();
r.sharedMesh.CombineMeshes(combineInstances.ToArray(), true, true);
r.sharedMaterial = mtrl;
r.bones = bones.ToArray();
r.sharedMesh.boneWeights = boneWeights.ToArray();
r.sharedMesh.bindposes = bindposes.ToArray();
r.sharedMesh.RecalculateBounds();
}
public override void ShowViseme(SkinnedMeshRenderer skinnedMeshRenderer, int incrementationSpeed, int overallIntensity)
{
base.ShowViseme(skinnedMeshRenderer, incrementationSpeed, overallIntensity);
}
private ExporterMorph(DirectoryInfo dir, Animator parser, SkinnedMeshRenderer morphObj)
{
this.parser = parser;
this.morphObj = morphObj;
}
private void FixMaterials([NotNull] SkinnedMeshRenderer prefabRenderer, [NotNull] SkinnedMeshRenderer instanceRenderer, [NotNull] ModelFixerOptions options)
{
var oldMaterials = prefabRenderer.sharedMaterials;
var newMaterials = instanceRenderer.materials;
var materialCount = oldMaterials.Length;
for (var i = 0; i < materialCount; i += 1)
{
var oldMaterial = oldMaterials[i];
var newMaterial = newMaterials[i];
if (oldMaterial.name.Contains("skin"))
{
newMaterial = Instantiate(skinMaterial);
ApplyNewMaterial(oldMaterial, newMaterial);
newMaterials[i] = newMaterial;
}
else if (oldMaterial.name.Contains("face"))
{
newMaterial = Instantiate(skinMaterialNoShade);
ApplyNewMaterial(oldMaterial, newMaterial);
newMaterials[i] = newMaterial;
}
else if (oldMaterial.name.EndsWith("cut"))
{
// newMaterial.shader = Shader.Find("Unlit/Transparent Cutout");
newMaterial = Instantiate(cutoutMaterial);
ApplyNewMaterial(oldMaterial, newMaterial);
newMaterials[i] = newMaterial;
}
else if (oldMaterial.name.Contains("eyel") || oldMaterial.name.Contains("eyer"))
{
if (options.EyesHighlights)
{
newMaterial.shader = Shader.Find("Unlit/Dual");
}
else
{
newMaterial.shader = Shader.Find("Unlit/Texture");
}
}
else if (oldMaterial.name.Contains("hair"))
{
if (options.HairHighlights)
{
newMaterial.shader = Shader.Find("Unlit/Dual");
}
else
{
newMaterial.shader = Shader.Find("Unlit/Texture");
}
}
else
{
// newMaterial.shader = Shader.Find("Unlit/Texture");
newMaterial = Instantiate(clothesMaterial);
ApplyNewMaterial(oldMaterial, newMaterial);
newMaterials[i] = newMaterial;
}
}
instanceRenderer.materials = newMaterials;
}
public static SkinnedMeshRenderer CreateSkinnedMeshRenderer(Animator parser, List<Material> materials, WorkspaceMesh mesh, Matrix meshMatrix, out int[] indices, out bool[] worldCoords, out bool[] replaceSubmeshesOption)
{
int numUncheckedSubmeshes = 0;
foreach (ImportedSubmesh submesh in mesh.SubmeshList)
{
if (!mesh.isSubmeshEnabled(submesh))
{
numUncheckedSubmeshes++;
}
}
int numSubmeshes = mesh.SubmeshList.Count - numUncheckedSubmeshes;
indices = new int[numSubmeshes];
worldCoords = new bool[numSubmeshes];
replaceSubmeshesOption = new bool[numSubmeshes];
List<Matrix> poseMatrices = new List<Matrix>(mesh.BoneList.Count);
Transform animatorTransform = parser.m_GameObject.instance.FindLinkedComponent(UnityClassID.Transform);
List<PPtr<Transform>> bones = CreateBoneList(animatorTransform, meshMatrix, mesh.BoneList, poseMatrices);
SkinnedMeshRenderer sMesh = new SkinnedMeshRenderer(parser.file);
int totVerts = 0, totFaces = 0;
sMesh.m_Materials.Capacity = numSubmeshes;
foreach (ImportedSubmesh submesh in mesh.SubmeshList)
{
if (!mesh.isSubmeshEnabled(submesh))
{
continue;
}
Material matFound = materials.Find
(
delegate(Material mat)
{
return mat.m_Name == submesh.Material;
}
);
sMesh.m_Materials.Add(new PPtr<Material>(matFound));
totVerts += submesh.VertexList.Count;
totFaces += submesh.FaceList.Count;
}
Mesh uMesh = new Mesh(parser.file);
uMesh.m_Name = mesh.Name;
sMesh.m_Mesh = new PPtr<Mesh>(uMesh);
sMesh.m_Bones = bones;
uMesh.m_BindPose = poseMatrices;
uMesh.m_BoneNameHashes = new List<uint>(poseMatrices.Count);
for (int i = 0; i < mesh.BoneList.Count; i++)
{
string bone = mesh.BoneList[i].Name;
uint hash = parser.m_Avatar.instance.BoneHash(bone);
uMesh.m_BoneNameHashes.Add(hash);
}
uMesh.m_VertexData = new VertexData((uint)totVerts);
uMesh.m_Skin = new List<BoneInfluence>(totVerts);
uMesh.m_IndexBuffer = new byte[totFaces * 3 * sizeof(ushort)];
using (BinaryWriter vertWriter = new BinaryWriter(new MemoryStream(uMesh.m_VertexData.m_DataSize)),
indexWriter = new BinaryWriter(new MemoryStream(uMesh.m_IndexBuffer)))
{
uMesh.m_LocalAABB.m_Center = new Vector3(Single.MaxValue, Single.MaxValue, Single.MaxValue);
uMesh.m_LocalAABB.m_Extend = new Vector3(Single.MinValue, Single.MinValue, Single.MinValue);
uMesh.m_SubMeshes = new List<SubMesh>(numSubmeshes);
int vertIndex = 0;
for (int i = 0, submeshIdx = 0; i < numSubmeshes; i++, submeshIdx++)
{
while (!mesh.isSubmeshEnabled(mesh.SubmeshList[submeshIdx]))
{
submeshIdx++;
}
SubMesh submesh = new SubMesh();
submesh.indexCount = (uint)mesh.SubmeshList[submeshIdx].FaceList.Count * 3;
submesh.vertexCount = (uint)mesh.SubmeshList[submeshIdx].VertexList.Count;
submesh.firstVertex = (uint)vertIndex;
uMesh.m_SubMeshes.Add(submesh);
indices[i] = mesh.SubmeshList[submeshIdx].Index;
worldCoords[i] = mesh.SubmeshList[submeshIdx].WorldCoords;
replaceSubmeshesOption[i] = mesh.isSubmeshReplacingOriginal(mesh.SubmeshList[submeshIdx]);
List<ImportedVertex> vertexList = mesh.SubmeshList[submeshIdx].VertexList;
Vector3 min = new Vector3(Single.MaxValue, Single.MaxValue, Single.MaxValue);
Vector3 max = new Vector3(Single.MinValue, Single.MinValue, Single.MinValue);
for (int str = 0; str < uMesh.m_VertexData.m_Streams.Count; str++)
{
StreamInfo sInfo = uMesh.m_VertexData.m_Streams[str];
if (sInfo.channelMask == 0)
{
continue;
}
for (int j = 0; j < vertexList.Count; j++)
{
ImportedVertex vert = vertexList[j];
for (int chn = 0; chn < uMesh.m_VertexData.m_Channels.Count; chn++)
{
ChannelInfo cInfo = uMesh.m_VertexData.m_Channels[chn];
if ((sInfo.channelMask & (1 << chn)) == 0)
{
continue;
}
vertWriter.BaseStream.Position = sInfo.offset + (j + submesh.firstVertex) * sInfo.stride + cInfo.offset;
switch (chn)
{
case 0:
Vector3 pos = vert.Position;
pos.X *= -1;
vertWriter.Write(pos);
min = Vector3.Minimize(min, pos);
max = Vector3.Maximize(max, pos);
break;
case 1:
Vector3 normal = vert.Normal;
normal.X *= -1;
vertWriter.Write(normal);
break;
case 3:
vertWriter.Write(vert.UV);
break;
case 5:
Vector4 tangent = vert.Tangent;
tangent.X *= -1;
tangent.W *= -1;
vertWriter.Write(tangent);
break;
}
}
if (sMesh.m_Bones.Count > 0 && sInfo.offset == 0 && uMesh.m_Skin.Count < totVerts)
{
BoneInfluence item = new BoneInfluence();
for (int k = 0; k < 4; k++)
{
item.boneIndex[k] = vert.BoneIndices[k] != 0xFF ? vert.BoneIndices[k] : 0;
}
vert.Weights.CopyTo(item.weight, 0);
uMesh.m_Skin.Add(item);
}
}
}
vertIndex += (int)submesh.vertexCount;
submesh.localAABB.m_Extend = max - min;
submesh.localAABB.m_Center = min + submesh.localAABB.m_Extend / 2;
uMesh.m_LocalAABB.m_Extend = Vector3.Maximize(uMesh.m_LocalAABB.m_Extend, max);
uMesh.m_LocalAABB.m_Center = Vector3.Minimize(uMesh.m_LocalAABB.m_Center, min);
List<ImportedFace> faceList = mesh.SubmeshList[submeshIdx].FaceList;
submesh.firstByte = (uint)indexWriter.BaseStream.Position;
for (int j = 0; j < faceList.Count; j++)
{
int[] vertexIndices = faceList[j].VertexIndices;
indexWriter.Write((ushort)(vertexIndices[0] + submesh.firstVertex));
indexWriter.Write((ushort)(vertexIndices[2] + submesh.firstVertex));
indexWriter.Write((ushort)(vertexIndices[1] + submesh.firstVertex));
}
}
uMesh.m_LocalAABB.m_Extend -= uMesh.m_LocalAABB.m_Center;
uMesh.m_LocalAABB.m_Center += uMesh.m_LocalAABB.m_Extend / 2;
}
return sMesh;
}
protected virtual void CreateHighlightRenderers()
{
existingSkinnedRenderers = this.GetComponentsInChildren <SkinnedMeshRenderer>(true);
highlightHolder = new GameObject("Highlighter");
highlightSkinnedRenderers = new SkinnedMeshRenderer[existingSkinnedRenderers.Length];
for (int skinnedIndex = 0; skinnedIndex < existingSkinnedRenderers.Length; skinnedIndex++)
{
SkinnedMeshRenderer existingSkinned = existingSkinnedRenderers[skinnedIndex];
if (ShouldIgnoreHighlight(existingSkinned))
{
continue;
}
GameObject newSkinnedHolder = new GameObject("SkinnedHolder");
newSkinnedHolder.transform.parent = highlightHolder.transform;
SkinnedMeshRenderer newSkinned = newSkinnedHolder.AddComponent <SkinnedMeshRenderer>();
Material[] materials = new Material[existingSkinned.sharedMaterials.Length];
for (int materialIndex = 0; materialIndex < materials.Length; materialIndex++)
{
materials[materialIndex] = highlightMat;
}
newSkinned.sharedMaterials = materials;
newSkinned.sharedMesh = existingSkinned.sharedMesh;
newSkinned.rootBone = existingSkinned.rootBone;
newSkinned.updateWhenOffscreen = existingSkinned.updateWhenOffscreen;
newSkinned.bones = existingSkinned.bones;
highlightSkinnedRenderers[skinnedIndex] = newSkinned;
}
MeshFilter[] existingFilters = this.GetComponentsInChildren <MeshFilter>(true);
existingRenderers = new MeshRenderer[existingFilters.Length];
highlightRenderers = new MeshRenderer[existingFilters.Length];
for (int filterIndex = 0; filterIndex < existingFilters.Length; filterIndex++)
{
MeshFilter existingFilter = existingFilters[filterIndex];
MeshRenderer existingRenderer = existingFilter.GetComponent <MeshRenderer>();
if (existingFilter == null || existingRenderer == null || ShouldIgnoreHighlight(existingFilter))
{
continue;
}
GameObject newFilterHolder = new GameObject("FilterHolder");
newFilterHolder.transform.parent = highlightHolder.transform;
MeshFilter newFilter = newFilterHolder.AddComponent <MeshFilter>();
newFilter.sharedMesh = existingFilter.sharedMesh;
MeshRenderer newRenderer = newFilterHolder.AddComponent <MeshRenderer>();
Material[] materials = new Material[existingRenderer.sharedMaterials.Length];
for (int materialIndex = 0; materialIndex < materials.Length; materialIndex++)
{
materials[materialIndex] = highlightMat;
}
newRenderer.sharedMaterials = materials;
highlightRenderers[filterIndex] = newRenderer;
existingRenderers[filterIndex] = existingRenderer;
}
}
public void SetTweenFactor(SkinnedMeshRenderer sMesh, float tweenFactor)
{
foreach (AnimationFrame frame in meshFrames)
{
Transform meshTransform = sMesh.m_GameObject.instance.FindLinkedComponent(UnityClassID.Transform);
if (frame.Name == meshTransform.GetTransformPath())
{
MorphMeshContainer morphMesh = frame.MeshContainer as MorphMeshContainer;
for (int meshObjIdx = 0; morphMesh != null; meshObjIdx++)
{
morphMesh.TweenFactor = tweenFactor;
morphMesh = morphMesh.NextMeshContainer as MorphMeshContainer;
}
return;
}
}
Report.ReportLog("Mesh frame " + sMesh.m_GameObject.instance.m_Name + " not displayed.");
}
// Cache variables
bool DefineComponents()
{
// Check if prefab
if (gameObject.scene.rootCount == 0)
{
Debug.Log("Shatter component unable to fragment prefab because prefab unable to store Unity mesh. Fragment prefab in scene.");
return(false);
}
// Mesh storage
meshFilter = GetComponent <MeshFilter>();
skinnedMeshRend = GetComponent <SkinnedMeshRenderer>();
//
if (meshFilter == null && skinnedMeshRend == null)
{
Debug.Log("No mesh");
return(false);
}
if (meshFilter != null && meshFilter.sharedMesh == null)
{
Debug.Log("No mesh");
return(false);
}
if (skinnedMeshRend != null && skinnedMeshRend.sharedMesh == null)
{
Debug.Log("No mesh");
return(false);
}
// Not readable mesh
if (meshFilter != null && meshFilter.sharedMesh.isReadable == false)
{
Debug.Log("Mesh is not readable. Open Import Settings and turn On Read/Write Enabled", meshFilter.gameObject);
return(false);
}
// Get components
transForm = GetComponent <Transform>();
origSubMeshIdsRF = new List <RFDictionary>();
// Mesh renderer
if (skinnedMeshRend == null)
{
meshRenderer = GetComponent <MeshRenderer>();
if (meshRenderer == null)
{
meshRenderer = gameObject.AddComponent <MeshRenderer>();
}
bound = meshRenderer.bounds;
}
// Skinned mesh
if (skinnedMeshRend != null)
{
bound = skinnedMeshRend.bounds;
}
return(true);
}
public dynamic LoadComponent(Stream stream, int index, NotLoaded comp)
{
stream.Position = comp.offset;
try
{
switch (comp.classID1)
{
case UnityClassID.AnimationClip:
{
AnimationClip animationClip = new AnimationClip(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animationClip, comp);
animationClip.LoadFrom(stream);
return animationClip;
}
case UnityClassID.Animator:
{
Animator animator = new Animator(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animator, comp);
animator.LoadFrom(stream);
return animator;
}
case UnityClassID.AnimatorController:
{
AnimatorController animatorController = new AnimatorController(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, animatorController, comp);
animatorController.LoadFrom(stream);
return animatorController;
}
case UnityClassID.AssetBundle:
{
AssetBundle assetBundle = new AssetBundle(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, assetBundle, comp);
assetBundle.LoadFrom(stream);
return assetBundle;
}
case UnityClassID.AudioClip:
{
if (loadingReferencials)
{
return comp;
}
AudioClip ac = new AudioClip(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ac, comp);
ac.LoadFrom(stream);
return ac;
}
case UnityClassID.AudioListener:
{
AudioListener audioListener = new AudioListener(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, audioListener, comp);
audioListener.LoadFrom(stream);
return audioListener;
}
case UnityClassID.AudioSource:
{
AudioSource audioSrc = new AudioSource(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, audioSrc, comp);
audioSrc.LoadFrom(stream);
return audioSrc;
}
case UnityClassID.Avatar:
{
if (loadingReferencials)
{
return comp;
}
Avatar avatar = new Avatar(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, avatar, comp);
avatar.LoadFrom(stream);
return avatar;
}
case UnityClassID.BoxCollider:
{
BoxCollider boxCol = new BoxCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, boxCol, comp);
boxCol.LoadFrom(stream);
return boxCol;
}
case UnityClassID.Camera:
{
Camera camera = new Camera(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, camera, comp);
camera.LoadFrom(stream);
return camera;
}
case UnityClassID.CapsuleCollider:
{
CapsuleCollider capsuleCol = new CapsuleCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, capsuleCol, comp);
capsuleCol.LoadFrom(stream);
return capsuleCol;
}
case UnityClassID.Cubemap:
{
Cubemap cubemap = new Cubemap(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, cubemap, comp);
cubemap.LoadFrom(stream);
Parser.Textures.Add(cubemap);
return cubemap;
}
case UnityClassID.EllipsoidParticleEmitter:
{
EllipsoidParticleEmitter ellipsoid = new EllipsoidParticleEmitter(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ellipsoid, comp);
ellipsoid.LoadFrom(stream);
return ellipsoid;
}
case UnityClassID.FlareLayer:
{
FlareLayer flareLayer = new FlareLayer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, flareLayer, comp);
flareLayer.LoadFrom(stream);
return flareLayer;
}
case UnityClassID.Light:
{
Light light = new Light(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, light, comp);
light.LoadFrom(stream);
return light;
}
case UnityClassID.LinkToGameObject:
{
LinkToGameObject link = new LinkToGameObject(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.LinkToGameObject223:
{
LinkToGameObject223 link = new LinkToGameObject223(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.LinkToGameObject225:
{
LinkToGameObject225 link = new LinkToGameObject225(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, link, comp);
link.LoadFrom(stream);
return link;
}
case UnityClassID.GameObject:
{
GameObject gameObj = new GameObject(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, gameObj, comp);
gameObj.LoadFrom(stream);
return gameObj;
}
case UnityClassID.Material:
{
Material mat = new Material(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, mat, comp);
mat.LoadFrom(stream);
return mat;
}
case UnityClassID.Mesh:
{
if (loadingReferencials)
{
return comp;
}
Mesh mesh = new Mesh(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, mesh, comp);
mesh.LoadFrom(stream);
return mesh;
}
case UnityClassID.MeshCollider:
{
MeshCollider meshCol = new MeshCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshCol, comp);
meshCol.LoadFrom(stream);
return meshCol;
}
case UnityClassID.MeshFilter:
{
MeshFilter meshFilter = new MeshFilter(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshFilter, comp);
meshFilter.LoadFrom(stream);
return meshFilter;
}
case UnityClassID.MeshRenderer:
{
MeshRenderer meshRenderer = new MeshRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, meshRenderer, comp);
meshRenderer.LoadFrom(stream);
return meshRenderer;
}
default:
if (comp.classID2 == UnityClassID.MonoBehaviour)
{
if (Types.Count > 0)
{
MonoBehaviour monoBehaviour = new MonoBehaviour(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, monoBehaviour, comp);
monoBehaviour.LoadFrom(stream);
return monoBehaviour;
}
else
{
string message = comp.classID2 + " unhandled because of absence of Types in Cabinet (*.assets)";
if (!reported.Contains(message))
{
Report.ReportLog(message);
reported.Add(message);
}
return comp;
}
}
else
{
string message = "Unhandled class: " + comp.classID1 + "/" + comp.classID2;
if (!reported.Contains(message))
{
Report.ReportLog(message);
reported.Add(message);
}
}
break;
case UnityClassID.MonoScript:
{
if (loadingReferencials)
{
return comp;
}
MonoScript monoScript = new MonoScript(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, monoScript, comp);
monoScript.LoadFrom(stream);
return monoScript;
}
case UnityClassID.MultiLink:
{
MultiLink multi = new MultiLink(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, multi, comp);
multi.LoadFrom(stream);
return multi;
}
case UnityClassID.ParticleAnimator:
{
ParticleAnimator particleAnimator = new ParticleAnimator(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleAnimator, comp);
particleAnimator.LoadFrom(stream);
return particleAnimator;
}
case UnityClassID.ParticleRenderer:
{
ParticleRenderer particleRenderer = new ParticleRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleRenderer, comp);
particleRenderer.LoadFrom(stream);
return particleRenderer;
}
case UnityClassID.ParticleSystem:
{
ParticleSystem particleSystem = new ParticleSystem(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleSystem, comp);
particleSystem.LoadFrom(stream);
return particleSystem;
}
case UnityClassID.ParticleSystemRenderer:
{
ParticleSystemRenderer particleSystemRenderer = new ParticleSystemRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, particleSystemRenderer, comp);
particleSystemRenderer.LoadFrom(stream);
return particleSystemRenderer;
}
case UnityClassID.Projector:
{
Projector projector = new Projector(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, projector, comp);
projector.LoadFrom(stream);
return projector;
}
case UnityClassID.Rigidbody:
{
RigidBody rigidBody = new RigidBody(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, rigidBody, comp);
rigidBody.LoadFrom(stream);
return rigidBody;
}
case UnityClassID.Shader:
{
Shader shader = new Shader(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, shader, comp);
shader.LoadFrom(stream);
return shader;
}
case UnityClassID.SkinnedMeshRenderer:
{
SkinnedMeshRenderer sMesh = new SkinnedMeshRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sMesh, comp);
sMesh.LoadFrom(stream);
return sMesh;
}
case UnityClassID.SphereCollider:
{
SphereCollider sphereCol = new SphereCollider(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sphereCol, comp);
sphereCol.LoadFrom(stream);
return sphereCol;
}
case UnityClassID.Sprite:
{
Sprite sprite = new Sprite(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, sprite, comp);
sprite.LoadFrom(stream);
return sprite;
}
case UnityClassID.SpriteRenderer:
{
SpriteRenderer spriteRenderer = new SpriteRenderer(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, spriteRenderer, comp);
spriteRenderer.LoadFrom(stream);
return spriteRenderer;
}
case UnityClassID.TextAsset:
{
if (loadingReferencials)
{
return comp;
}
TextAsset ta = new TextAsset(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, ta, comp);
ta.LoadFrom(stream);
return ta;
}
case UnityClassID.Texture2D:
{
if (loadingReferencials)
{
return comp;
}
Texture2D tex = new Texture2D(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, tex, comp);
tex.LoadFrom(stream);
Parser.Textures.Add(tex);
return tex;
}
case UnityClassID.Transform:
{
Transform trans = new Transform(this, comp.pathID, comp.classID1, comp.classID2);
ReplaceSubfile(index, trans, comp);
trans.LoadFrom(stream);
return trans;
}
}
}
catch
{
Report.ReportLog("Failed to load " + comp.classID1 + "/" + comp.classID2 + " PathID=" + comp.pathID);
foreach (NotLoaded notLoaded in RemovedList)
{
if (notLoaded == comp)
{
RemovedList.Remove(notLoaded);
Components.RemoveAt(index);
notLoaded.replacement = null;
Components.Insert(index, notLoaded);
break;
}
}
}
return null;
}
public void AssetUnload()
{
if (!this._loading)
{
switch (this._type)
{
case BundledAssetLoader.AssetTypes.Mesh:
((MeshFilter)this._target).mesh = null;
base.GetComponent <Renderer>().enabled = false;
break;
case BundledAssetLoader.AssetTypes.SkinnedMesh:
{
SkinnedMeshRenderer skinnedMeshRenderer = (SkinnedMeshRenderer)this._target;
skinnedMeshRenderer.sharedMesh = null;
skinnedMeshRenderer.enabled = false;
break;
}
case BundledAssetLoader.AssetTypes.Texture:
((Material)this._target).mainTexture = null;
base.GetComponent <Renderer>().enabled = false;
break;
case BundledAssetLoader.AssetTypes.Material:
{
Renderer renderer = (Renderer)this._target;
renderer.sharedMaterial = null;
renderer.enabled = false;
break;
}
case BundledAssetLoader.AssetTypes.SwitcherLod0:
{
playerMeshSwitcher playerMeshSwitcher = (playerMeshSwitcher)this._target;
playerMeshSwitcher.Lod0 = null;
playerMeshSwitcher.enabled = false;
playerMeshSwitcher.Skin.sharedMesh = null;
playerMeshSwitcher.Skin.enabled = false;
break;
}
case BundledAssetLoader.AssetTypes.SwitcherLod1:
{
playerMeshSwitcher playerMeshSwitcher2 = (playerMeshSwitcher)this._target;
playerMeshSwitcher2.Lod1 = null;
playerMeshSwitcher2.enabled = false;
playerMeshSwitcher2.Skin.sharedMesh = null;
playerMeshSwitcher2.Skin.enabled = false;
break;
}
case BundledAssetLoader.AssetTypes.SwitcherLod2:
{
playerMeshSwitcher playerMeshSwitcher3 = (playerMeshSwitcher)this._target;
playerMeshSwitcher3.Lod2 = null;
playerMeshSwitcher3.enabled = false;
playerMeshSwitcher3.Skin.sharedMesh = null;
playerMeshSwitcher3.Skin.enabled = false;
break;
}
}
AssetBundleManager.UnloadAssetBundle(this._bundleName);
}
}
