public static void registerLinkedData(Material mat, ResourceMapper resMap)
{
if (!mat)
{
return;
}
registerLinkedTex(mat, TexParamNames.main, resMap);
registerLinkedTex(mat, TexParamNames.specular, resMap);
registerLinkedTex(mat, TexParamNames.metallic, resMap);
registerLinkedTex(mat, TexParamNames.normal, resMap);
registerLinkedTex(mat, TexParamNames.occlusion, resMap);
registerLinkedTex(mat, TexParamNames.parallax, resMap);
registerLinkedTex(mat, TexParamNames.emission, resMap);
registerLinkedTex(mat, TexParamNames.detailMask, resMap);
registerLinkedTex(mat, TexParamNames.detailAlbedo, resMap);
registerLinkedTex(mat, TexParamNames.detailNormal, resMap);
}
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 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 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 static JsonScene fromObjects(GameObject[] args, ResourceMapper resMap, bool showGui)
{
try{
var result = new JsonScene();
var objMap = new GameObjectMapper();
foreach (var curObj in args)
{
objMap.gatherObjectIds(curObj);
}
foreach (var curObj in objMap.objectList)
{
resMap.gatherPrefabData(curObj);
}
for (int i = 0; i < objMap.objectList.Count; i++)
{
/*TODO: The constructor CAN add more data, but most of it would've been added prior to this point.
* Contempalting whether to enforce it strictly or not.*/
if (showGui)
{
ExportUtility.showProgressBar("Collecting scene data",
string.Format("Adding scene object {0}/{1}", i, objMap.numObjects), i, objMap.objectList.Count);
}
var newObj = new JsonGameObject(objMap.objectList[i], objMap, resMap);
result.objects.Add(newObj);
}
return(result);
}
finally{
if (showGui)
{
ExportUtility.hideProgressBar();
}
}
}
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 JsonGameObject(GameObject obj, GameObjectMapper objMap, ResourceMapper resMap)
{
name = obj.name;
scenePath = obj.getScenePath();
instanceId = obj.GetInstanceID();
id = objMap.getId(obj);
localPosition = obj.transform.localPosition;
localRotation = obj.transform.localRotation;
localScale = obj.transform.localScale;
worldMatrix = obj.transform.localToWorldMatrix;
localMatrix = worldMatrix;
if (obj.transform.parent)
{
localMatrix = obj.transform.parent.worldToLocalMatrix * worldMatrix;
}
isStatic = obj.isStatic;
var flags = GameObjectUtility.GetStaticEditorFlags(obj);
lightMapStatic = (flags & StaticEditorFlags.LightmapStatic) != 0;
occluderStatic = (flags & StaticEditorFlags.OccluderStatic) != 0;
occludeeStatic = (flags & StaticEditorFlags.OccludeeStatic) != 0;
navigationStatic = (flags & StaticEditorFlags.NavigationStatic) != 0;
reflectionProbeStatic = (flags & StaticEditorFlags.ReflectionProbeStatic) != 0;
activeSelf = obj.activeSelf;
activeInHierarchy = obj.activeInHierarchy;
//var prefType = PrefabUtility.GetPrefabType(obj);
//prefabType = prefType.ToString();
prefabRootId = resMap.getRootPrefabId(obj, true);
prefabObjectId = resMap.getPrefabObjectId(obj, true);
prefabInstance = Utility.isPrefabInstance(obj) || Utility.isPrefabModelInstance(obj);
//prefabInstance = (prefType == PrefabType.PrefabInstance) || (prefType == PrefabType.ModelPrefabInstance);
renderer = JsonRendererData.makeRendererArray(obj.GetComponent <Renderer>(), resMap);
light = JsonLight.makeLightArray(obj.GetComponent <Light>());
reflectionProbes =
ExportUtility.convertComponents <ReflectionProbe, JsonReflectionProbe>(obj,
(c) => new JsonReflectionProbe(c, resMap)
);
terrains =
ExportUtility.convertComponents <Terrain, JsonTerrain>(obj,
(c) => new JsonTerrain(c, resMap)
);
skinRenderers =
ExportUtility.convertComponentsList <SkinnedMeshRenderer, JsonSkinRendererData>(obj,
(c) => new JsonSkinRendererData(c, objMap, resMap)
);
int colliderIndex = 0;
colliders = ExportUtility.convertComponentsList <Collider, JsonCollider>(
obj, (arg) => new JsonCollider(arg, colliderIndex++, resMap)
).Where(c => c.isSupportedType()).ToList();
for (int i = colliders.Count - 1; i >= 0; i--)
{
var curCollider = colliders[i];
if ((curCollider == null) || !curCollider.isSupportedType())
{
colliders.RemoveAt(i);
}
}
rigidbodies = ExportUtility.convertComponentsList <Rigidbody, JsonRigidbody>(
obj, (arg) => new JsonRigidbody(arg)
);
joints = ExportUtility.convertComponentsList <Joint, JsonPhysicsJoint>(
obj, (arg) => new JsonPhysicsJoint(arg)
);
/*
* if (rigidbodies.Count > 1){
* //Logger.log
* }
*/
///..... I think those can be replaced with linq queries (-_-)
/*
* animators = obj.GetComponents<Animator>().Where((arg) => arg)
* .Select((Animator arg) => new JsonAnimator(arg, resMap))
* .ToList();*/
animators =
ExportUtility.convertComponentsList <Animator, JsonAnimator>(obj,
(c) => new JsonAnimator(c, resMap));
var meshFilter = obj.GetComponent <MeshFilter>();
if (meshFilter)
{
mesh = resMap.getOrRegMeshId(meshFilter);
}
foreach (Transform curChild in obj.transform)
{
var childId = objMap.getId(curChild.gameObject);
/* ????
* if (childId < 0){
* //throw new System.ArgumentException("Could not find child id
* }
*/
if (!childId.isValid)
{
}
//var childId = objMap.getId(curChild.gameObject);
children.Add(childId);
childNames.Add(curChild.name);
}
if (obj.transform.parent)
{
parentName = obj.transform.parent.name;
parent = objMap.findId(obj.transform.parent.gameObject);
}
}
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 void clear()
{
config = new JsonProjectConfig();
scenes.Clear();
resourceMapper = new ResourceMapper();
}
void sampleMatrixCurves(ResourceMapper resMap, AnimationSampler providedSampler = null)
{
var skelId = resMap.skelRegistry.registerSkeleton(animator.transform, true);
if (!ExportUtility.isValidId(skelId))
{
throw new System.ArgumentException(
string.Format("Skeleton not found for clip \"{0}\" and animator \"{1}\"",
clip, animator));
}
var skeleton = resMap.skelRegistry.getSkeletonById(skelId);
var prefabAnim = Utility.getSrcPrefabAssetObject(animator, false);
if (providedSampler != null)
{
var sampled = providedSampler.sampleClip(clip);
matrixCurves = sampled; //.matrixCurves;
//sampledFloatCurves = sampled.floatCurves;
}
else
{
using (var sampler = new AnimationSampler(prefabAnim, skeleton)){
var sampled = sampler.sampleClip(clip);
matrixCurves = sampled; //.matrixCurves;
//sampledFloatCurves = sampled.floatCurves;
}
}
matrixCurves.forEach((obj) => obj.simpleCompress());
#if false
//Black magic: on!
//Spawning a duplicate
var spawnedAnimator = GameObject.Instantiate(prefabAnim);
if (!spawnedAnimator)
{
throw new System.Exception("Instantiating of original object failed while sampling animation");
}
var transformRoot = spawnedAnimator.transform;
var foundTransforms = Utility.findNamedTransforms(
skeleton.bones.Select((arg) => arg.name).ToList(),
transformRoot);
//This needs to be moved elsewhere.
var guidName = System.Guid.NewGuid().ToString("N");
var animControllerBaseAssetPath = string.Format("Assets/tmp-remapController-{0}.controller", guidName);
Debug.LogFormat("guid: {0}, basePath: {1}", guidName, animControllerBaseAssetPath);
var animControllerAssetPath = AssetDatabase.GenerateUniqueAssetPath(animControllerBaseAssetPath);
Debug.LogFormat("generated path: {0}", animControllerAssetPath);
var newController = UnityEditor.Animations.AnimatorController.CreateAnimatorControllerAtPath(
animControllerAssetPath);
var stateMachine = newController.layers[0].stateMachine;
var stateName = "clip";
var state = newController.layers[0].stateMachine.AddState(stateName);
stateMachine.defaultState = state;
spawnedAnimator.runtimeAnimatorController = newController;
var firstTime = 0.0f;
var lastTime = clip.length;
var timeStep = 1.0f / clip.frameRate;
spawnedAnimator.Play(stateName, 0, 0.0f);
for (int transformIndex = 0; transformIndex < foundTransforms.Count; transformIndex++)
{
var curTransform = foundTransforms[transformIndex];
var newCurve = new JsonAnimationMatrixCurve();
newCurve.objectName = skeleton.bones[transformIndex].name;
matrixCurves.Add(newCurve);
}
for (float t = firstTime; t <= lastTime; t += timeStep)
{
clip.SampleAnimation(spawnedAnimator.gameObject, t);
for (int transformIndex = 0; transformIndex < foundTransforms.Count; transformIndex++)
{
var curTransform = foundTransforms[transformIndex];
if (!curTransform)
{
continue;
}
matrixCurves[transformIndex].addKey(t, curTransform, spawnedAnimator.transform);
}
///sampleSingleFramePoints(spawnedAnimator, boneIds, t/lastTime);
}
foreach (var cur in matrixCurves)
{
cur.simpleCompress();
}
if (spawnedAnimator)
{
GameObject.DestroyImmediate(spawnedAnimator.gameObject);
}
if (newController)
{
AssetDatabase.DeleteAsset(animControllerAssetPath);
}
#endif
}
public JsonSplatPrototype(SplatPrototype data_, ResourceMapper resMap)
{
data = data_;
textureId = resMap.getTextureId(data.texture);
normalMapId = resMap.getTextureId(data.normalMap);
}
public JsonMaterial(Material mat, ResourceMapper resMap)
{
name = mat.name;
//TODO: Further investigation shows that this is likely going to return -1 for all new materials.
id = resMap.findMaterialId(mat); //exp.materials.findId(mat);
renderQueue = mat.renderQueue;
var path = AssetDatabase.GetAssetPath(mat);
this.path = path;
shader = mat.shader.name;
supportedShader = isSupportedShaderName(shader);
mainTexture = resMap.getTextureId(mat.mainTexture);
mainTextureOffset = mat.mainTextureOffset;
mainTextureScale = mat.mainTextureScale;
color = getColor(mat, ParamNames.mainColor, Color.white); //mat.color;
useNormalMap = mat.IsKeywordEnabled(Keywords.normalMap); //"_NORMALMAP");
useAlphaTest = mat.IsKeywordEnabled(Keywords.alphaTestOn); //"_ALPHATEST_ON");
useAlphaBlend = mat.IsKeywordEnabled(Keywords.alphaBlendOn); //"_ALPHABLEND_ON");
useAlphaPremultiply = mat.IsKeywordEnabled(Keywords.alphaPremultiplyOn); //"_ALPHAPREMULTIPLY_ON");
useEmission = mat.IsKeywordEnabled(Keywords.emission); //"_EMISSION");
useParallax = mat.IsKeywordEnabled(Keywords.parallaxMap); //"_PARALLAXMAP");
useDetailMap = mat.IsKeywordEnabled(Keywords.detailMulX2); //"_DETAIL_MULX2");
useMetallic = mat.IsKeywordEnabled(Keywords.metallicGlossMap); //"_METALLICGLOSSMAP");
useSpecular = mat.IsKeywordEnabled(Keywords.specGlossMap); //"_SPECCGLOSSMAP");
albedoTex = getTexId(mat, TexParamNames.main, resMap);
specularTex = getTexId(mat, TexParamNames.specular, resMap);
metallicTex = getTexId(mat, TexParamNames.metallic, resMap);
normalMapTex = getTexId(mat, TexParamNames.normal, resMap);
occlusionTex = getTexId(mat, TexParamNames.occlusion, resMap);
parallaxTex = getTexId(mat, TexParamNames.parallax, resMap);
emissionTex = getTexId(mat, TexParamNames.emission, resMap);
detailMaskTex = getTexId(mat, TexParamNames.detailMask, resMap);
detailAlbedoTex = getTexId(mat, TexParamNames.detailAlbedo, resMap);
detailNormalMapTex = getTexId(mat, TexParamNames.detailNormal, resMap);
detailAlbedoScale = getTextureScale(mat, TexParamNames.detailAlbedo); //mat.GetTextureScale(TexParamNames.detailAlbedo);
detailAlbedoOffset = getTextureOffset(mat, TexParamNames.detailAlbedo); //mat.GetTextureOffset(TexParamNames.detailAlbedo);
detailNormalMapScale = getFloat(mat, ParamNames.detailNormalMapScale, 1.0f);
alphaCutoff = getFloat(mat, ParamNames.cutoff, 1.0f);
smoothness = getFloat(mat, ParamNames.glossiness, 0.5f);
smoothnessScale = getFloat(mat, ParamNames.glossinessScale, 1.0f);
specularColor = getColor(mat, ParamNames.specularColor, Color.white);
metallic = getFloat(mat, ParamNames.metallic, 0.5f);
bumpScale = getFloat(mat, ParamNames.bumpScale, 1.0f);
parallaxScale = getFloat(mat, ParamNames.parallax, 1.0f);
occlusionStrength = getFloat(mat, ParamNames.occlusionStrength, 1.0f);
emissionColor = getColor(mat, ParamNames.emissionColor, Color.black);
detailMapScale = getFloat(mat, ParamNames.detailNormalMapScale, 1.0f);
secondaryUv = getFloat(mat, ParamNames.secondaryUv, 1.0f);
blendMode = Mathf.RoundToInt(getFloat(mat, ParamNames.blendMode, 0.0f));
smoothnessMapChannel = (int)getFloat(mat, ParamNames.smoothnessMapChannel, 0.0f);
specularHighlights = getFloat(mat, ParamNames.specularHighlights, 1.0f);
glossyReflections = getFloat(mat, ParamNames.glossyReflections, 1.0f);
hasMetallic = mat.HasProperty(ParamNames.metallic) && mat.HasProperty(TexParamNames.metallic);
hasSpecular = mat.HasProperty(TexParamNames.specular) && mat.HasProperty(ParamNames.specularColor);
hasEmissionColor = mat.HasProperty(ParamNames.emissionColor) && (emissionColor.maxColorComponent > 0.01f);
hasEmission = hasEmissionColor || ExportUtility.isValidId(emissionTex); //(emissionTex >= 0);
}
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));
}
}
public JsonTerrainData(TerrainData terrainData_, ResourceMapper resMap)
{
if (!terrainData_)
{
throw new System.ArgumentNullException("terrainData_");
}
terrainData = terrainData_;
name = terrainData.name;
path = AssetDatabase.GetAssetPath(terrainData);
exportPath = string.Format("{0}/{1}", terrainAssetExportFolder, path); //System.IO.Path.Combine(terrainAssetExportFolder, path);
exportPath = System.IO.Path.ChangeExtension(exportPath, ".bin");
heightMapRawPath = System.IO.Path.ChangeExtension(exportPath, ".height.raw");
detailMapRawPaths.Clear();
alphaMapRawPaths.Clear();
for (int i = 0; i < terrainData.alphamapLayers; i++)
{
var rawExt = string.Format(".alpha{0}.raw", i);
alphaMapRawPaths.Add(System.IO.Path.ChangeExtension(exportPath, rawExt));
}
bounds = new JsonBounds(terrainData.bounds);
detailPrototypes.Clear();
var srcDetailPrototypes = terrainData.detailPrototypes;
foreach (var cur in srcDetailPrototypes)
{
detailPrototypes.Add(new JsonTerrainDetailPrototype(cur, resMap));
}
for (int i = 0; i < detailPrototypes.Count; i++)
{
var rawExt = string.Format(".detail{0}.raw", i);
detailMapRawPaths.Add(System.IO.Path.ChangeExtension(exportPath, rawExt));
}
var srcTreePrototypes = terrainData.treePrototypes;
treePrototypes.Clear();
foreach (var cur in srcTreePrototypes)
{
treePrototypes.Add(new JsonTreePrototype(cur, resMap));
}
//writer.writeKeyVal("treeInstances", treeInstances);
var srcTreeInstances = terrainData.treeInstances;
treeInstances.Clear();
foreach (var cur in srcTreeInstances)
{
treeInstances.Add(new JsonTreeInstance(cur));
}
var splats = terrainData.splatPrototypes;
splatPrototypes.Clear();
foreach (var cur in splats)
{
splatPrototypes.Add(new JsonSplatPrototype(cur, resMap));
}
//TODO: detail layer?
}
public static JsonScene fromObject(GameObject arg, ResourceMapper resMap, bool showGui)
{
return(fromObjects(new GameObject[] { arg }, resMap, showGui));
}
