public MeshStorageKey(Mesh mesh_, MeshUsageFlags usageFlags_, GameObject prefab_ = null, Transform skeletonRoot_ = null)
 {
     mesh         = mesh_;
     usageFlags   = usageFlags_;
     prefab       = prefab_;
     skeletonRoot = skeletonRoot_;
 }
        public ResId findMeshId(Mesh obj, MeshUsageFlags useFlags)
        {
            return(meshRegistry.findMeshId(obj, useFlags));

            /*
             * var key = new MeshStorageKey(obj);
             * return meshes.getId(key, false);
             */
        }
Exemplo n.º 3
0
		public JsonMesh(JsonMesh other){
			if (other == null)
				throw new System.ArgumentNullException();
			id = other.id;
			name = other.name;
			uniqueName = other.uniqueName;
			usageFlags = other.usageFlags;
			convexCollider = other.convexCollider;
			triangleCollider = other.triangleCollider;

			path = other.path;
			materials = other.materials.ToList();
			readable = other.readable;

			vertexCount = other.vertexCount;
			
			colors = other.colors.copyArray();
			verts = other.verts.copyArray();
			tangents = other.tangents.copyArray();
			
			uv0 = other.uv0.copyArray();
			uv1 = other.uv1.copyArray();
			uv2 = other.uv2.copyArray();
			uv3 = other.uv3.copyArray();
			uv4 = other.uv4.copyArray();
			uv5 = other.uv5.copyArray();
			uv6 = other.uv6.copyArray();
			uv7 = other.uv7.copyArray();
			
			boneWeights = other.boneWeights.ToList();
			boneIndexes = other.boneIndexes.ToList();
			
			defaultSkeletonId = other.defaultSkeletonId;
			
			defaultBoneNames = other.defaultBoneNames.ToList();
			
			defaultMeshNodeName = other.defaultMeshNodeName;
			defaultMeshNodePath = other.defaultMeshNodePath;
			defaultMeshNodeMatrix = other.defaultMeshNodeMatrix;
			
			blendShapeCount = other.blendShapeCount;
			blendShapes = other.blendShapes.Select((arg) => new JsonBlendShape(arg)).ToList();
			
			bindPoses = other.bindPoses.ToList();
			
			subMeshes = other.subMeshes.Select((arg) => new SubMesh(arg)).ToList();
			
			subMeshCount = other.subMeshCount;
		}
Exemplo n.º 4
0
		public JsonMesh(MeshStorageKey meshKey, ResId id_, ResourceMapper resMap){
			id = id_;
			usageFlags = meshKey.usageFlags;
			convexCollider = meshKey.usageFlags.HasFlag(MeshUsageFlags.ConvexCollider);
			triangleCollider = meshKey.usageFlags.HasFlag(MeshUsageFlags.TriangleCollider);

			var mesh = meshKey.mesh;
            if (mesh == null)
            {
                Debug.LogError("Mesh is null, name!");
                return;
            }
			name = mesh.name;
			var filePath = AssetDatabase.GetAssetPath(mesh);
			resMap.registerAssetPath(filePath);
			path = filePath;
			uniqueName = resMap.createUniqueAssetName(filePath, name, meshKey.getMeshAssetSuffix());

			var foundMaterials = resMap.findMeshMaterials(mesh);
			if (foundMaterials != null){
				foreach(var cur in foundMaterials){
					materials.Add(resMap.getMaterialId(cur));
				}
			}

			#if !UNITY_EDITOR
			readable = mesh.isReadable;
			if (!readable){
				Debug.LogErrorFormat(string.Format("Mesh {0} is not marked as readable. Cannot proceed", name);
				return;
			}
			#endif
			
			vertexCount = mesh.vertexCount;
			if (vertexCount <= 0)
				return;

			colors = mesh.colors32.toByteArray();
			verts = mesh.vertices.toFloatArray();
			normals = mesh.normals.toFloatArray();
			
			tangents = mesh.tangents.toFloatArray();
			
			uv0 = mesh.uv.toFloatArray();
			uv1 = mesh.uv2.toFloatArray();
			uv2 = mesh.uv3.toFloatArray();
			uv3 = mesh.uv4.toFloatArray();			
			uv4 = mesh.uv5.toFloatArray();			
			uv5 = mesh.uv6.toFloatArray();			
			uv6 = mesh.uv7.toFloatArray();			
			uv7 = mesh.uv8.toFloatArray();			

			subMeshCount = mesh.subMeshCount;
			for(int i = 0; i < subMeshCount; i++){
				var subMesh = new SubMesh();
				subMesh.triangles = Utility.copyArray(mesh.GetTriangles(i));
				subMeshes.Add(subMesh);
			}
			
			boneWeights.Clear();
			boneIndexes.Clear();
			defaultSkeletonId = resMap.skelRegistry.getDefaultSkeletonId(meshKey);
			defaultBoneNames = resMap.skelRegistry.getDefaultBoneNames(meshKey);
			
			defaultMeshNodeName = resMap.skelRegistry.getDefaultMeshNodeName(meshKey);
			defaultMeshNodePath = resMap.skelRegistry.getDefaultMeshNodePath(meshKey);
			defaultMeshNodeMatrix = resMap.skelRegistry.getDefaultMeshNodeMatrix(meshKey);
			
			var srcWeights = mesh.boneWeights;
			if ((srcWeights != null) && (srcWeights.Length > 0)){
				foreach(var cur in srcWeights){
					boneIndexes.Add(cur.boneIndex0);
					boneIndexes.Add(cur.boneIndex1);
					boneIndexes.Add(cur.boneIndex2);
					boneIndexes.Add(cur.boneIndex3);
					
					boneWeights.Add(cur.weight0);
					boneWeights.Add(cur.weight1);
					boneWeights.Add(cur.weight2);
					boneWeights.Add(cur.weight3);
				}
			}
			
			blendShapeCount = mesh.blendShapeCount;
			blendShapes.Clear();
			for(int i = 0; i < blendShapeCount; i++){
				blendShapes.Add(new JsonBlendShape(mesh, i));
			}
			
			bindPoses = mesh.bindposes.ToList();
		}
 public ResId getMeshId(Mesh obj, MeshUsageFlags useFlags)
 {
     return(meshRegistry.getMeshId(obj, useFlags));
 }
        public ResId findMeshId(Mesh obj, MeshUsageFlags useFlags)
        {
            var key = new MeshStorageKey(obj, useFlags);

            return(meshes.getId(key, false));
        }