public JsonTreePrototype(TreePrototype src_, ResourceMapper resMap)
{
src = src_;
prefabId = resMap.getRootPrefabId(src.prefab, true);
prefabObjectId = resMap.getPrefabObjectId(src.prefab, true);
meshIdData = new MeshIdData(src.prefab, resMap);
/*
* meshId = -1;
* meshMaterials.Clear();
*
* var srcObj = src.prefab as GameObject;
* if (!srcObj)
* return;
* var filter = srcObj.GetComponent<MeshFilter>();
* if (filter && filter.sharedMesh){
* meshId = resMap.getMeshId(filter.sharedMesh);
* }
* var renderer = srcObj.GetComponent<Renderer>();
* if (renderer){
* foreach(var cur in renderer.sharedMaterials){
* meshMaterials.Add(resMap.getMaterialId(cur));
* }
* }
*/
}
JsonMesh makeJsonMesh(MeshStorageKey meshKey, ResId id)
{
var result = new JsonMesh(meshKey, id, this);
if (!meshKey.skeletonRoot || !meshKey.prefab)
{
return(result);
}
if (!isSkeletalMesh(meshKey.mesh))
{
return(result);
}
/*
* Doing this in steps, as it is possible to have root transform issue and then somehow no bindpose issues.
* I mean, miracles can happen, right?
*/
result = fixSkinMeshRootBoneTransform(meshKey, result);
//Currently disabled
//result = fixSkinMeshPosedBones(meshKey, result);
return(result);
}
public bool processRemainingItems(ResourceProcessCallback callback)
{
if (callback == null)
{
throw new System.ArgumentNullException("callback");
}
if (!hasUnprocessedItems)
{
return(false);
}
for (int i = numProcessedItems; i < numRegisteredItems; i++)
{
var id = new ResId(i);
var obj = registered[i];
try{
callback(obj, id);
}
finally{
processed.Add(obj);
}
//resourceMap.Add(obj, id);, No this should be done earlier
}
return(true);
}
public JsonSkinRendererData(SkinnedMeshRenderer rend, GameObjectMapper objMap, ResourceMapper resMap)
{
if (!rend)
{
throw new System.ArgumentNullException("rend");
}
quality = rend.quality.ToString();
skinnedMotionVectors = rend.skinnedMotionVectors;
updateWhenOffscreen = rend.updateWhenOffscreen;
boneNames.Clear();
boneIds.Clear();
foreach (var cur in rend.bones)
{
boneNames.Add(cur.name);
boneTransforms.Add(cur.localToWorldMatrix);
boneIds.Add(objMap.getId(cur.gameObject));
}
var sharedMesh = rend.sharedMesh;
meshId = resMap.getOrRegMeshId(rend, null); //resMap.getMeshId(sharedMesh);
materials.Clear();
var sharedMats = rend.sharedMaterials;
foreach (var curMat in sharedMats)
{
materials.Add(resMap.getMaterialId(curMat));
}
}
void checkValidId(ResId id)
{
if (!isValidId(id))
{
throw new System.ArgumentException(string.Format("Invalid skeleton id {0}", id));
}
}
public ResId getId(Resource res, bool createNew, bool throwIfMissing = false)
{
if (res == null)
{
if (createNew && (res == null) && throwIfMissing)
{
throw new System.ArgumentNullException("resType");
}
return(ResId.invalid);
}
ResId result;
if (resourceMap.TryGetValue(res, out result))
{
return(result);
}
if (!createNew)
{
return(ResId.invalid);
}
result = new ResId(numRegisteredItems);
registered.Add(res);
resourceMap.Add(res, result);
return(result);
}
public Transform getSkeletonTransformById(ResId id)
{
checkValidId(id);
var skelTransform = jsonSkeletonRootTransforms.getValOrDefault(id, null);
return(skelTransform);
}
public ResId registerSkeleton(Transform rootTransform, bool findPrefab)
{
if (findPrefab)
{
rootTransform = Utility.getSrcPrefabAssetObject(rootTransform, false);
}
JsonSkeleton skel = findSkeleton(rootTransform);
if (skel != null)
{
var testId = findSkeletonId(rootTransform);
Sanity.check(testId == skel.id, "ID mismatch within skeleton registry");
return(skel.id);
}
/* if (jsonSkeletons.TryGetValue(rootTransform, out skel))
* return skel.id;*/
var newSkel = JsonSkeletonBuilder.buildFromRootTransform(rootTransform);
var newId = ResId.fromObjectIndex(skeletons.Count); //ResId.fromObjectIndex(jsonSkeletons.Count);
Sanity.check(skeletons.Count == sortedSkelIds.Count, "Skeleton id and skeleton count mismatch");
newSkel.id = newId;
//jsonSkeletons.Add(rootTransform, newSkel);
skelIds.Add(rootTransform, newId);
skeletons.Add(newId, newSkel);
sortedSkelIds.Add(newId);
jsonSkeletonRootTransforms.Add(newSkel.id, rootTransform);
return(newSkel.id);
}
/*
* Uh, do we even need temporary object with all those fields?
* Could just grab reflection probes themselves in this case...
*/
public JsonReflectionProbe(ReflectionProbe obj, ResourceMapper resMap)
{
backgroundColor = obj.backgroundColor;
blendDistance = obj.blendDistance;
boxProjection = obj.boxProjection;
center = obj.center;
size = obj.size;
/*clearType = (obj.clearFlags == UnityEngine.Rendering.ReflectionProbeClearFlags.Skybox) ?
* "skybox": "color";*/
clearType = obj.clearFlags.ToString();
cullingMask = obj.cullingMask;
hdr = obj.hdr;
intensity = obj.intensity;
nearClipPlane = obj.nearClipPlane;
farClipPlane = obj.farClipPlane;
resolution = obj.resolution;
mode = obj.mode.ToString(); //getModeString(obj.mode);
refreshMode = obj.refreshMode.ToString(); //getModeString(obj.mode);
var customCubemap = obj.customBakedTexture as Cubemap;
var customTex2d = obj.customBakedTexture as Texture2D;
customCubemapId = resMap.getCubemapId(customCubemap);
customTex2dId = resMap.getTextureId(customTex2d);
}
public JsonAnimator(Animator animator_, ResourceMapper resMap)
{
animator = animator_;
if (!animator_)
{
throw new System.ArgumentNullException("animator_");
}
name = animator.name;
skeletonId = resMap.skelRegistry.registerSkeleton(animator.transform, true);
//var skel = resMap.getSkeletonById(skeletonId);
var skelTransform = resMap.skelRegistry.getSkeletonTransformById(skeletonId);
//var root = PrefabUtility.FindPrefabRoot(skelTransform.gameObject);
//var meshKey = new MeshStorageKey(
var skinRends = animator.GetComponentsInChildren <SkinnedMeshRenderer>();
skinMeshIds = skinRends.Select((arg) => resMap.getOrRegMeshId(arg, skelTransform)).ToList();
var runtimeAnimator = animator.runtimeAnimatorController;
var editorAnimator = runtimeAnimator as UnityEditor.Animations.AnimatorController;
animatorControllerId = resMap.getAnimatorControllerId(editorAnimator, animator);
humanBones = gatherHumanBones(animator);
}
public IEnumerable <ResId> getNewIds()
{
foreach (var index in getNewIndexes())
{
yield return(ResId.fromObjectIndex(index));
}
}
public Resource getObject(ResId id)
{
if (!isValidObjectId(id))
{
throw new System.ArgumentException(string.Format("Invalid object id {0}", id));
}
return(objectList[id.rawId]);
}
public Resource findResource(ResId id)
{
if (isValidId(id))
{
return(registered[id.rawId]);
}
return(null);
}
public JsonAudioClip(AudioClip clip_, ResourceMapper resMap)
{
audioClip = clip_;
if (!audioClip)
{
return;
}
name = audioClip.name;
id = resMap.getAudioClipId(audioClip);
assetPath = AssetDatabase.GetAssetPath(audioClip);
}
public JsonTerrainDetailPrototype(DetailPrototype data_, ResourceMapper resMap)
{
data = data_;
textureId = resMap.getTextureId(data.prototypeTexture);
detailPrefabId = resMap.getRootPrefabId(data.prototype, true);
detailPrefabObjectId = resMap.getPrefabObjectId(data.prototype, true);
meshIdData = new MeshIdData(data.prototype, resMap);
//meshId = resMap.getPrefabObjectId
}
public Bone(string name_, string path_, int id_, ResId parentId_, Matrix4x4 world_, Matrix4x4 local_, Matrix4x4 rootRelative_)
{
name = name_;
path = path_;
id = id_;
parentId = parentId_;
world = world_;
local = local_;
rootRelative = rootRelative_;
}
public JsonCollider(Collider col, int colliderIndex_, ResourceMapper resMap)
{
colliderIndex = colliderIndex_;
if (!col)
{
throw new System.ArgumentNullException("col");
}
if (resMap == null)
{
throw new System.ArgumentNullException("resMap");
}
var box = col as BoxCollider;
var sphere = col as SphereCollider;
var capsule = col as CapsuleCollider;
var meshCol = col as MeshCollider;
collider = col;
if (box)
{
colliderType = colliderTypeBox;
center = box.center;
size = box.size;
}
if (sphere)
{
colliderType = colliderTypeSphere;
center = sphere.center;
radius = sphere.radius;
}
if (capsule)
{
colliderType = colliderTypeCapsule;
center = capsule.center;
radius = capsule.radius;
height = capsule.height;
direction = capsule.direction;
}
if (meshCol)
{
colliderType = colliderTypeMesh;
meshId = resMap.getMeshId(meshCol.sharedMesh,
meshCol.convex ? MeshUsageFlags.ConvexCollider: MeshUsageFlags.TriangleCollider
);
bool isConvex = meshCol.convex;
/*
* if (resMap.isValidMeshId(meshId))
* resMap.flagMeshId(meshId, isConvex, !isConvex);//by default there will be no flags on a mesh...
*/
}
}
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;
}
public JsonTerrain(Terrain srcObj, ResourceMapper resMap)
{
if (!srcObj)
{
throw new System.ArgumentNullException("srcObj");
}
castShadows = srcObj.castShadows;
detailObjectDensity = srcObj.detailObjectDensity;
detailObjectDistance = srcObj.detailObjectDistance;
drawHeightmap = srcObj.drawHeightmap;
drawTreesAndFoliage = srcObj.drawTreesAndFoliage;
renderHeightmap = (srcObj.editorRenderFlags & TerrainRenderFlags.Heightmap) != 0;
renderTrees = (srcObj.editorRenderFlags & TerrainRenderFlags.Trees) != 0;
renderDetails = (srcObj.editorRenderFlags & TerrainRenderFlags.Details) != 0;
heightmapPixelError = srcObj.heightmapPixelError;
legacyShininess = srcObj.legacyShininess;
legacySpecular = srcObj.legacySpecular;
lightmapIndex = srcObj.lightmapIndex;
lightmapScaleOffet = srcObj.lightmapScaleOffset;
materialType = srcObj.materialType.ToString();
patchBoundsMultiplier = srcObj.patchBoundsMultiplier;
preserveTreePrototypeLayers = srcObj.preserveTreePrototypeLayers;
realtimeLightmapIndex = srcObj.realtimeLightmapIndex;
realtimeLightmapScaleOffset = srcObj.realtimeLightmapScaleOffset;
treeBillboardDistance = srcObj.treeBillboardDistance;
treeCrossFadeLength = srcObj.treeCrossFadeLength;
treeDistance = srcObj.treeDistance;
treeLodBiasMultiplier = srcObj.treeLODBiasMultiplier;
treeMaximumFullLODCount = srcObj.treeMaximumFullLODCount;
//And once again I doubt whehter the approahc of making a temporary object is justified.
materialTemplateIndex = ResId.invalid;
if (srcObj.materialType == Terrain.MaterialType.Custom)
{
materialTemplateIndex = resMap.getMaterialId(srcObj.materialTemplate); //-1;
}
//material keeps picking up splat texutre :-\
terrainDataId = resMap.getTerrainId(srcObj.terrainData);
//public int terrainDataId = -1;
}
protected ResId addNewObjectInternal(Resource obj, OnNewObjectAdded onAddCallback = null)
{
if (objectMap.ContainsKey(obj))
{
throw new System.ArgumentException("Logic error: duplicate registertation");
}
var result = new ResId(objectList.Count);
objectMap.Add(obj, result);
objectList.Add(obj);
if (onAddCallback != null)
{
onAddCallback(obj);
}
return(result);
}
public JsonSkeleton getSkeletonById(ResId id)
{
var skelTransform = getSkeletonTransformById(id);
if (!skelTransform)
{
throw new System.ArgumentException(string.Format("skeleton with id {0} not found", id));
}
var result = findSkeleton(skelTransform);
if (result == null)
{
throw new System.ArgumentException(string.Format("skeleton with id {0} not found", id));
}
return(result);
}
public JsonAnimatorController(UnityEditor.Animations.AnimatorController controller_, Animator animator, ResId id_, ResourceMapper resMap)
{
controller = controller_;
if (!controller)
{
throw new System.ArgumentNullException("controller_");
}
if (!animator)
{
throw new System.ArgumentNullException("animator");
}
id = id_;
name = controller.name;
path = AssetDatabase.GetAssetPath(controller);
parameters = controller.parameters.Select((arg) => new JsonAnimatorControllerParameter(arg)).ToList();
animationIds = controller.animationClips.Select((arg) => resMap.getAnimationClipId(arg, animator)).ToList();
//animations = controller.animationClips.Select((arg, idx) => new JsonAnimationClip(arg, idx)).ToList();
}
public JsonTexture(Texture tex, ResourceMapper resMap)
{
name = tex.name;
id = resMap.findTextureId(tex); //exp.textures.findId(tex);
var assetPath = AssetDatabase.GetAssetPath(tex);
resMap.registerAssetPath(assetPath);
path = assetPath;
filterMode = tex.filterMode.ToString();
width = tex.width;
height = tex.height;
wrapMode = tex.wrapMode.ToString();
var tex2D = tex as Texture2D;
var rendTarget = tex as RenderTexture;
isTex2D = tex2D != null;
isRenderTarget = rendTarget != null;
var importer = AssetImporter.GetAtPath(assetPath);
var texImporter = importer as TextureImporter; //(TextureImporter)importer;
if (isTex2D)
{
alphaTransparency = tex2D.alphaIsTransparency;
format = tex2D.format.ToString();
}
if (isRenderTarget)
{
anisoLevel = rendTarget.anisoLevel;
}
if (texImporter)
{
importDataFound = true;
sRGB = texImporter.sRGBTexture;
textureType = texImporter.textureType.ToString();
normalMapFlag = (texImporter.textureType == TextureImporterType.NormalMap);
}
texParams = new JsonTextureParameters(tex);
texImportParams = new JsonTextureImportParameters(texImporter);
textureRef = tex;
}
public JsonCubemap(Cubemap cubemap_, ResourceMapper resMap)
{
cubemap = cubemap_;
if (!cubemap)
{
return;
}
id = resMap.findCubemapId(cubemap);
assetPath = AssetDatabase.GetAssetPath(cubemap);
name = cubemap.name;
var importer = AssetImporter.GetAtPath(assetPath);
var texImporter = importer as TextureImporter;
texParams = new JsonTextureParameters(cubemap);
texImportParams = new JsonTextureImportParameters(texImporter);
needConversion = true;
/*
* if (TextureUtility.isSupportedTexExtension(assetPath))
* needConversion = true;
* if (texImportParams.initialized && texImportParams.importer){
* if (texImportParams.importer.generateCubemap != TextureImporterGenerateCubemap.FullCubemap){
* needConversion = true;
* }
* //huh.... I don't really have a way to get original texture dimensiosn, it looks like it. Oh well?
* }
*/
format = cubemap.format.ToString();
isHdr = TextureUtility.isHdrFormat(cubemap.format);
exportPath = assetPath;
rawPath = "";
if (needConversion)
{
exportPath = System.IO.Path.ChangeExtension(assetPath, ".png");
rawPath = System.IO.Path.ChangeExtension(assetPath, ".raw");
}
}
public JsonAnimationClip(AnimationClip clip_, Animator animator_, ResId id_, ResourceMapper resMap, AnimationSampler animSampler = null)
{
clip = clip_;
id = id_;
animator = animator_;
if (!clip)
{
throw new System.ArgumentNullException("clip_");
}
if (!animator)
{
throw new System.ArgumentNullException("animator_");
}
if (resMap == null)
{
throw new System.ArgumentNullException("resMap");
}
name = clip.name;
sampleMatrixCurves(resMap, animSampler);
}
public ResId getOrRegMeshId(MeshStorageKey meshKey, GameObject obj, Mesh mesh)
{
if (!mesh)
{
return(ResId.invalid);
}
ResId result = meshes.getId(meshKey, true, null);
if (meshMaterials.ContainsKey(mesh))
{
return(result);
}
var r = obj.GetComponent <Renderer>();
if (r)
{
meshMaterials[mesh] = new List <Material>(r.sharedMaterials);
}
return(result);
}
public JsonPrefabData(GameObject prefabObject, ResourceMapper resMap)
{
id = resMap.getRootPrefabId(prefabObject, true);
path = AssetDatabase.GetAssetPath(prefabObject);
guid = AssetDatabase.AssetPathToGUID(path);
//name = System.IO.Path.GetFileName(path);
name = prefabObject.name; //looks like name of prefab mirrors that of a file, sans extension
//prefabType = PrefabUtility.GetPrefabType(prefabObject).ToString();
prefabAssetType = PrefabUtility.GetPrefabAssetType(prefabObject).ToString();
prefabInstanceStatus = PrefabUtility.GetPrefabInstanceStatus(prefabObject).ToString();
var mapper = resMap.getPrefabObjectMapper(prefabObject);
for (int i = 0; i < mapper.numObjects; i++)
{
///Well, this is certainly not the best way to go about it...
var src = mapper.getObjectByIndex(i);
var dst = new JsonGameObject(src, mapper, resMap);
objects.Add(dst);
}
}
public MeshIdData(GameObject srcObj, ResourceMapper resMap)
{
if (!srcObj)
{
return;
}
var filter = srcObj.GetComponent <MeshFilter>();
if (filter && filter.sharedMesh)
{
meshId = resMap.getMeshId(filter.sharedMesh, MeshUsageFlags.None);
}
var renderer = srcObj.GetComponent <Renderer>();
if (renderer)
{
foreach (var cur in renderer.sharedMaterials)
{
meshMaterials.Add(resMap.getMaterialId(cur));
}
}
}
public static bool isValidId(ResId id)
{
return(id.isValid);
}
public void writeRawValue(ResId val)
{
//builder.Append(val.rawId);
builder.Append(val.rawId.ToString(writerCulture));
}
