2337 lines
59 KiB
C#
2337 lines
59 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using GLTF.Schema;
|
|
using UnityEngine;
|
|
using UnityGLTF.Extensions;
|
|
using UnityEditor;
|
|
using System.Text.RegularExpressions;
|
|
|
|
namespace UnityGLTF
|
|
{
|
|
public class GLTFEditorExporter
|
|
{
|
|
private Transform[] _rootTransforms;
|
|
private GLTFRoot _root;
|
|
private BufferId _bufferId;
|
|
private GLTF.Schema.Buffer _buffer;
|
|
private BinaryWriter _bufferWriter;
|
|
private List<Texture2D> _images;
|
|
private List<UnityEngine.Texture> _textures;
|
|
private List<UnityEngine.Material> _materials;
|
|
private Dictionary<int, int> _exportedTransforms;
|
|
private List<Transform> _animatedNodes;
|
|
private List<Transform> _skinnedNodes;
|
|
private Dictionary<SkinnedMeshRenderer, UnityEngine.Mesh> _bakedMeshes;
|
|
|
|
// Temporary setting to avoid validation issue 'not multiple of 4' in bufferView.offset
|
|
private bool _forceIndicesUint = true;
|
|
|
|
private bool _exportAnimation = true;
|
|
private bool _bakeSkinnedMeshes = false;
|
|
private Dictionary<string, string> _exportedFiles;
|
|
|
|
protected struct PrimKey
|
|
{
|
|
public UnityEngine.Mesh Mesh;
|
|
public UnityEngine.Material Material;
|
|
}
|
|
private readonly Dictionary<PrimKey, MeshId> _primOwner = new Dictionary<PrimKey, MeshId>();
|
|
private readonly Dictionary<UnityEngine.Mesh, MeshPrimitive[]> _meshToPrims = new Dictionary<UnityEngine.Mesh, MeshPrimitive[]>();
|
|
|
|
private GLTFTextureUtilsCache _textureCache;
|
|
public bool ExportNames = true;
|
|
|
|
public enum MaterialDoubleSidedExport {
|
|
Default,
|
|
FrontSide,
|
|
DoubleSide
|
|
}
|
|
|
|
public static MaterialDoubleSidedExport materialExportOption = MaterialDoubleSidedExport.Default;
|
|
|
|
// Progress
|
|
public enum EXPORT_STEP
|
|
{
|
|
NODES,
|
|
ANIMATIONS,
|
|
SKINNING,
|
|
IMAGES
|
|
}
|
|
public delegate void ProgressCallback(EXPORT_STEP step, float current, float total);
|
|
public delegate void FinishCallback();
|
|
ProgressCallback _progressCallback;
|
|
FinishCallback _finishCallback;
|
|
|
|
/// <summary>
|
|
/// Create a GLTFExporter that exports out a transform
|
|
/// </summary>
|
|
public GLTFEditorExporter()
|
|
{
|
|
initializeStructures();
|
|
}
|
|
|
|
public void setProgressCallback(ProgressCallback cb)
|
|
{
|
|
_progressCallback = cb;
|
|
}
|
|
|
|
private void updateProgress(EXPORT_STEP step, float current, float total)
|
|
{
|
|
if(_progressCallback != null)
|
|
{
|
|
_progressCallback(step, current, total);
|
|
}
|
|
}
|
|
|
|
public void setExportFinishCallback(FinishCallback cb)
|
|
{
|
|
_finishCallback = cb;
|
|
}
|
|
|
|
public void triggerFinishCallback()
|
|
{
|
|
if (_finishCallback != null)
|
|
_finishCallback();
|
|
|
|
}
|
|
/// <summary>
|
|
/// Create a GLTFExporter that exports out a transform
|
|
/// </summary>
|
|
public GLTFEditorExporter(string generator)
|
|
{
|
|
initializeStructures(generator);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a GLTFExporter that exports out a transform
|
|
/// </summary>
|
|
/// <param name="rootTransforms">Root transform of object to export</param>
|
|
public GLTFEditorExporter(Transform[] rootTransforms, string generator = "")
|
|
{
|
|
initializeStructures(generator);
|
|
_rootTransforms = rootTransforms;
|
|
}
|
|
|
|
public void setTransforms(Transform[] rootTransforms)
|
|
{
|
|
_rootTransforms = rootTransforms;
|
|
}
|
|
|
|
public void enableAnimation(bool enable)
|
|
{
|
|
_exportAnimation = enable;
|
|
}
|
|
|
|
private void initializeStructures(string generator = "")
|
|
{
|
|
_exportedTransforms = new Dictionary<int, int>();
|
|
_animatedNodes = new List<Transform>();
|
|
_skinnedNodes = new List<Transform>();
|
|
_exportedFiles = new Dictionary<string, string>();
|
|
_textureCache = new GLTFTextureUtilsCache();
|
|
_bakedMeshes = new Dictionary<SkinnedMeshRenderer, UnityEngine.Mesh>();
|
|
|
|
_root = new GLTFRoot
|
|
{
|
|
Accessors = new List<Accessor>(),
|
|
Animations = new List<GLTF.Schema.Animation>(),
|
|
Asset = new Asset
|
|
{
|
|
Version = "2.0",
|
|
Generator = generator.Length > 0 ? generator : "Plattar UnityGLTF (" + Application.unityVersion + ")"
|
|
},
|
|
Buffers = new List<GLTF.Schema.Buffer>(),
|
|
BufferViews = new List<BufferView>(),
|
|
ExtensionsUsed = new List<string>(),
|
|
ExtensionsRequired = new List<string>(),
|
|
Images = new List<Image>(),
|
|
Materials = new List<GLTF.Schema.Material>(),
|
|
Meshes = new List<GLTF.Schema.Mesh>(),
|
|
Nodes = new List<Node>(),
|
|
Samplers = new List<Sampler>(),
|
|
Scenes = new List<Scene>(),
|
|
Skins = new List<Skin>(),
|
|
Textures = new List<GLTF.Schema.Texture>(),
|
|
};
|
|
|
|
_images = new List<Texture2D>();
|
|
_materials = new List<UnityEngine.Material>();
|
|
_textures = new List<UnityEngine.Texture>();
|
|
|
|
_buffer = new GLTF.Schema.Buffer();
|
|
_bufferId = new BufferId
|
|
{
|
|
Id = _root.Buffers.Count,
|
|
Root = _root
|
|
};
|
|
_root.Buffers.Add(_buffer);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the root object of the exported GLTF
|
|
/// </summary>
|
|
/// <returns>Root parsed GLTF Json</returns>
|
|
public GLTFRoot GetRoot() {
|
|
return _root;
|
|
}
|
|
|
|
public Dictionary<string, string> getExportedFilesList()
|
|
{
|
|
return _exportedFiles;
|
|
}
|
|
|
|
public void clear()
|
|
{
|
|
initializeStructures();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specifies the path and filename for the GLTF Json and binary
|
|
/// </summary>
|
|
/// <param name="path">File path for saving the GLTF and binary files</param>
|
|
/// <param name="fileName">The name of the GLTF file</param>
|
|
public void SaveGLTFandBin(string path, string fileName)
|
|
{
|
|
string binPath = Path.Combine(path, fileName + ".bin");
|
|
var binFile = File.Create(binPath);
|
|
_bufferWriter = new BinaryWriter(binFile);
|
|
|
|
_root.Scene = ExportScene(fileName, _rootTransforms);
|
|
if (_exportAnimation)
|
|
{
|
|
exportAnimation();
|
|
// Export skins
|
|
for (int i = 0; i < _skinnedNodes.Count; ++i)
|
|
{
|
|
Transform t = _skinnedNodes[i];
|
|
exportSkinFromNode(t);
|
|
|
|
updateProgress(EXPORT_STEP.SKINNING, i, _skinnedNodes.Count);
|
|
}
|
|
}
|
|
|
|
|
|
_buffer.Uri = fileName + ".bin";
|
|
_buffer.ByteLength = (int)_bufferWriter.BaseStream.Length;
|
|
|
|
_exportedFiles.Add(binPath, "");
|
|
|
|
string gltfPath = Path.Combine(path, fileName + ".gltf");
|
|
var gltfFile = File.CreateText(gltfPath);
|
|
_root.Serialize(gltfFile);
|
|
|
|
#if WINDOWS_UWP
|
|
gltfFile.Dispose();
|
|
binFile.Dispose();
|
|
#else
|
|
gltfFile.Close();
|
|
binFile.Close();
|
|
#endif
|
|
_exportedFiles.Add(gltfPath, "");
|
|
bool backup = GL.sRGBWrite;
|
|
GL.sRGBWrite = true;
|
|
foreach (var image in _images)
|
|
{
|
|
//Should filter regarding channel that use it
|
|
string outputPath = Path.Combine(path, GLTFUtils.buildImageName(image)); // Png by default, but will be changed in write function
|
|
string finalOutputPath = GLTFTextureUtils.writeTextureOnDisk(_textureCache.flipTexture(image), outputPath, true);
|
|
try {
|
|
_exportedFiles.Add(finalOutputPath, "");
|
|
}
|
|
catch (Exception e) {
|
|
throw new Exception("The File " + outputPath + " has alredy been used. Ensure your file names are unique.");
|
|
}
|
|
|
|
updateProgress(EXPORT_STEP.IMAGES, _images.IndexOf(image), _images.Count);
|
|
}
|
|
GL.sRGBWrite = backup;
|
|
triggerFinishCallback();
|
|
}
|
|
|
|
private void exportAnimation()
|
|
{
|
|
for (int i = 0; i < _animatedNodes.Count; ++i)
|
|
{
|
|
Transform t = _animatedNodes[i];
|
|
exportAnimationFromNode(ref t);
|
|
|
|
updateProgress(EXPORT_STEP.ANIMATIONS, i, _animatedNodes.Count);
|
|
}
|
|
}
|
|
|
|
private UnityEngine.Mesh getMesh(GameObject gameObject)
|
|
{
|
|
if(gameObject.GetComponent<MeshFilter>())
|
|
{
|
|
return gameObject.GetComponent<MeshFilter>().sharedMesh;
|
|
}
|
|
|
|
SkinnedMeshRenderer skinMesh = gameObject.GetComponent<SkinnedMeshRenderer>();
|
|
if (skinMesh)
|
|
{
|
|
if(!_exportAnimation && _bakeSkinnedMeshes)
|
|
{
|
|
if(!_bakedMeshes.ContainsKey(skinMesh))
|
|
{
|
|
UnityEngine.Mesh bakedMesh = new UnityEngine.Mesh();
|
|
skinMesh.BakeMesh(bakedMesh);
|
|
_bakedMeshes.Add(skinMesh, bakedMesh);
|
|
}
|
|
|
|
return _bakedMeshes[skinMesh];
|
|
}
|
|
|
|
return gameObject.GetComponent<SkinnedMeshRenderer>().sharedMesh;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private UnityEngine.Material getMaterial(GameObject gameObject)
|
|
{
|
|
if (gameObject.GetComponent<MeshRenderer>())
|
|
{
|
|
return gameObject.GetComponent<MeshRenderer>().sharedMaterial;
|
|
}
|
|
|
|
if (gameObject.GetComponent<SkinnedMeshRenderer>())
|
|
{
|
|
return gameObject.GetComponent<SkinnedMeshRenderer>().sharedMaterial;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private UnityEngine.Material[] getMaterials(GameObject gameObject)
|
|
{
|
|
if (gameObject.GetComponent<MeshRenderer>())
|
|
{
|
|
return gameObject.GetComponent<MeshRenderer>().sharedMaterials;
|
|
}
|
|
|
|
if (gameObject.GetComponent<SkinnedMeshRenderer>())
|
|
{
|
|
return gameObject.GetComponent<SkinnedMeshRenderer>().sharedMaterials;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private int countNodes(Transform[] trs)
|
|
{
|
|
int ct = 0;
|
|
foreach (Transform tr in trs)
|
|
{
|
|
countRecursive(tr, ref ct);
|
|
}
|
|
|
|
return ct;
|
|
}
|
|
|
|
private void countRecursive(Transform tr, ref int count)
|
|
{
|
|
count += 1;
|
|
if (tr.childCount > 0)
|
|
{
|
|
for (int i = 0; i < tr.childCount; ++i)
|
|
{
|
|
countRecursive(tr.GetChild(i), ref count);
|
|
}
|
|
}
|
|
}
|
|
|
|
private SceneId ExportScene(string name, Transform[] rootObjTransforms)
|
|
{
|
|
var scene = new Scene();
|
|
|
|
if (ExportNames)
|
|
{
|
|
scene.Name = name;
|
|
}
|
|
int nodeCount = countNodes(rootObjTransforms);
|
|
scene.Nodes = new List<NodeId>(rootObjTransforms.Length);
|
|
foreach (var transform in rootObjTransforms)
|
|
{
|
|
scene.Nodes.Add(ExportNode(transform, nodeCount));
|
|
}
|
|
|
|
_root.Scenes.Add(scene);
|
|
|
|
return new SceneId {
|
|
Id = _root.Scenes.Count - 1,
|
|
Root = _root
|
|
};
|
|
}
|
|
|
|
private NodeId ExportNode(Transform nodeTransform, int nodeCount)
|
|
{
|
|
var node = new Node();
|
|
|
|
if (ExportNames)
|
|
{
|
|
node.Name = nodeTransform.name;
|
|
}
|
|
if(nodeTransform.GetComponent<UnityEngine.Animation>() || nodeTransform.GetComponent<UnityEngine.Animator>())
|
|
{
|
|
_animatedNodes.Add(nodeTransform);
|
|
}
|
|
if(nodeTransform.GetComponent<SkinnedMeshRenderer>())
|
|
{
|
|
_skinnedNodes.Add(nodeTransform);
|
|
}
|
|
// If object is on top of the selection, use global transform
|
|
bool useLocal = !Array.Exists(_rootTransforms, element => element == nodeTransform);
|
|
node.SetUnityTransform(nodeTransform, useLocal);
|
|
|
|
var id = new NodeId {
|
|
Id = _root.Nodes.Count,
|
|
Root = _root
|
|
};
|
|
|
|
// Register nodes for animation parsing (could be disabled is animation is disables)
|
|
_exportedTransforms.Add(nodeTransform.GetInstanceID(), _root.Nodes.Count);
|
|
|
|
_root.Nodes.Add(node);
|
|
// Update progress
|
|
updateProgress(EXPORT_STEP.NODES, _root.Nodes.Count, nodeCount);
|
|
|
|
// children that are primitives get put in a mesh
|
|
GameObject[] primitives, nonPrimitives;
|
|
FilterPrimitives(nodeTransform, out primitives, out nonPrimitives);
|
|
if (primitives.Length > 0)
|
|
{
|
|
node.Mesh = ExportMesh(nodeTransform.name, primitives);
|
|
|
|
// associate unity meshes with gltf mesh id
|
|
foreach (var prim in primitives)
|
|
{
|
|
_primOwner[new PrimKey { Mesh = getMesh(prim), Material = getMaterial(prim) }] = node.Mesh;
|
|
}
|
|
}
|
|
|
|
// children that are not primitives get added as child nodes
|
|
if (nonPrimitives.Length > 0)
|
|
{
|
|
node.Children = new List<NodeId>(nonPrimitives.Length);
|
|
foreach(var child in nonPrimitives)
|
|
{
|
|
node.Children.Add(ExportNode(child.transform, nodeCount));
|
|
}
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
private void FilterPrimitives(Transform transform, out GameObject[] primitives, out GameObject[] nonPrimitives)
|
|
{
|
|
var childCount = transform.childCount;
|
|
var prims = new List<GameObject>(childCount+1);
|
|
var nonPrims = new List<GameObject>(childCount);
|
|
|
|
// add another primitive if the root object also has a mesh
|
|
if (GLTFUtils.isValidMeshObject(transform.gameObject))
|
|
{
|
|
prims.Add(transform.gameObject);
|
|
}
|
|
|
|
for (var i = 0; i < childCount; i++)
|
|
{
|
|
var go = transform.GetChild(i).gameObject;
|
|
nonPrims.Add(go);
|
|
}
|
|
|
|
primitives = prims.ToArray();
|
|
nonPrimitives = nonPrims.ToArray();
|
|
}
|
|
|
|
private static bool IsPrimitive(GameObject gameObject)
|
|
{
|
|
/*
|
|
* Primitives have the following properties:
|
|
* - have no children
|
|
* - have no non-default local transform properties
|
|
* - have MeshFilter and MeshRenderer components
|
|
*/
|
|
return gameObject.transform.childCount == 0
|
|
&& gameObject.transform.localPosition == Vector3.zero
|
|
&& gameObject.transform.localRotation == Quaternion.identity
|
|
&& gameObject.transform.localScale == Vector3.one
|
|
&& GLTFUtils.isValidMeshObject(gameObject);
|
|
}
|
|
|
|
private MeshId ExportMesh(string name, GameObject[] primitives)
|
|
{
|
|
// check if this set of primitives is already a mesh
|
|
MeshId existingMeshId = null;
|
|
var key = new PrimKey();
|
|
foreach (var prim in primitives)
|
|
{
|
|
key.Mesh = getMesh(prim);
|
|
key.Material = getMaterial(prim);
|
|
|
|
MeshId tempMeshId;
|
|
if (_primOwner.TryGetValue(key, out tempMeshId) && (existingMeshId == null || tempMeshId == existingMeshId))
|
|
{
|
|
existingMeshId = tempMeshId;
|
|
}
|
|
else
|
|
{
|
|
existingMeshId = null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if so, return that mesh id
|
|
if(existingMeshId != null)
|
|
return existingMeshId;
|
|
|
|
// if not, create new mesh and return its id
|
|
var mesh = new GLTF.Schema.Mesh();
|
|
|
|
if (ExportNames)
|
|
{
|
|
mesh.Name = name;
|
|
}
|
|
|
|
mesh.Primitives = new List<MeshPrimitive>(primitives.Length);
|
|
foreach (var prim in primitives)
|
|
{
|
|
mesh.Primitives.AddRange(ExportPrimitive(prim));
|
|
}
|
|
|
|
var id = new MeshId
|
|
{
|
|
Id = _root.Meshes.Count,
|
|
Root = _root
|
|
};
|
|
_root.Meshes.Add(mesh);
|
|
|
|
return id;
|
|
}
|
|
|
|
// a mesh *might* decode to multiple prims if there are submeshes
|
|
private MeshPrimitive[] ExportPrimitive(GameObject gameObject)
|
|
{
|
|
var meshObj = getMesh(gameObject);
|
|
|
|
var materialsObj = getMaterials(gameObject);
|
|
|
|
var prims = new MeshPrimitive[meshObj.subMeshCount];
|
|
|
|
// don't export any more accessors if this mesh is already exported
|
|
MeshPrimitive[] primVariations;
|
|
if (_meshToPrims.TryGetValue(meshObj, out primVariations)
|
|
&& meshObj.subMeshCount == primVariations.Length)
|
|
{
|
|
for (var i = 0; i < primVariations.Length; i++)
|
|
{
|
|
prims[i] = primVariations[i].Clone();
|
|
if(materialsObj[i])
|
|
prims[i].Material = ExportMaterial(materialsObj[i]);
|
|
}
|
|
|
|
return prims;
|
|
}
|
|
|
|
AccessorId aPosition = null, aNormal = null, aTangent = null,
|
|
aTexcoord0 = null, aTexcoord1 = null, aColor0 = null;
|
|
|
|
aPosition = ExportVerticesAccessor(meshObj.vertices, gameObject, true);
|
|
|
|
if (meshObj.normals.Length != 0)
|
|
aNormal = ExportAccessor(meshObj.normals, true);
|
|
|
|
if (meshObj.tangents.Length != 0)
|
|
aTangent = ExportAccessor(meshObj.tangents, true);
|
|
|
|
if (meshObj.uv.Length != 0)
|
|
aTexcoord0 = ExportAccessor(meshObj.uv);
|
|
|
|
if (meshObj.uv2.Length != 0)
|
|
aTexcoord1 = ExportAccessor(meshObj.uv2);
|
|
|
|
if (meshObj.colors.Length != 0)
|
|
aColor0 = ExportAccessor(meshObj.colors);
|
|
|
|
MaterialId lastMaterialId = null;
|
|
|
|
for (var submesh = 0; submesh < meshObj.subMeshCount; submesh++)
|
|
{
|
|
var primitive = new MeshPrimitive();
|
|
|
|
var triangles = meshObj.GetTriangles(submesh);
|
|
primitive.Indices = ExportAccessor(FlipFaces(triangles), true);
|
|
|
|
primitive.Attributes = new Dictionary<string, AccessorId>();
|
|
primitive.Attributes.Add(SemanticProperties.POSITION, aPosition);
|
|
|
|
if (aNormal != null)
|
|
primitive.Attributes.Add(SemanticProperties.NORMAL, aNormal);
|
|
if (aTangent != null)
|
|
primitive.Attributes.Add(SemanticProperties.TANGENT, aTangent);
|
|
if (aTexcoord0 != null)
|
|
primitive.Attributes.Add(SemanticProperties.TexCoord(0), aTexcoord0);
|
|
if (aTexcoord1 != null)
|
|
primitive.Attributes.Add(SemanticProperties.TexCoord(1), aTexcoord1);
|
|
if (aColor0 != null)
|
|
primitive.Attributes.Add(SemanticProperties.Color(0), aColor0);
|
|
|
|
if (submesh < materialsObj.Length && materialsObj[submesh])
|
|
{
|
|
primitive.Material = ExportMaterial(materialsObj[submesh]);
|
|
lastMaterialId = primitive.Material;
|
|
}
|
|
else
|
|
{
|
|
primitive.Material = lastMaterialId;
|
|
}
|
|
|
|
prims[submesh] = primitive;
|
|
}
|
|
|
|
_meshToPrims[meshObj] = prims;
|
|
|
|
return prims;
|
|
}
|
|
|
|
private MaterialId ExportMaterial(UnityEngine.Material materialObj)
|
|
{
|
|
MaterialId id = GetMaterialId(_root, materialObj);
|
|
if (id != null)
|
|
{
|
|
return id;
|
|
}
|
|
|
|
var material = new GLTF.Schema.Material();
|
|
|
|
if (ExportNames)
|
|
{
|
|
material.Name = materialObj.name;
|
|
}
|
|
|
|
if (materialObj.HasProperty("_Cutoff"))
|
|
{
|
|
material.AlphaCutoff = materialObj.GetFloat("_Cutoff");
|
|
}
|
|
|
|
switch (materialObj.GetTag("RenderType", false, ""))
|
|
{
|
|
case "TransparentCutout":
|
|
material.AlphaMode = AlphaMode.MASK;
|
|
break;
|
|
case "Transparent":
|
|
material.AlphaMode = AlphaMode.BLEND;
|
|
break;
|
|
default:
|
|
material.AlphaMode = AlphaMode.OPAQUE;
|
|
break;
|
|
}
|
|
|
|
if (materialExportOption == MaterialDoubleSidedExport.DoubleSide) {
|
|
material.DoubleSided = true;
|
|
}
|
|
else if (materialExportOption == MaterialDoubleSidedExport.FrontSide) {
|
|
material.DoubleSided = false;
|
|
}
|
|
else {
|
|
material.DoubleSided = materialObj.HasProperty("_Cull") &&
|
|
materialObj.GetInt("_Cull") == (float)UnityEngine.Rendering.CullMode.Off;
|
|
}
|
|
|
|
if (materialObj.IsKeywordEnabled("_EMISSION") && materialObj.HasProperty("_EmissionColor"))
|
|
{
|
|
material.EmissiveFactor = materialObj.GetColor("_EmissionColor").ToNumericsColor();
|
|
}
|
|
|
|
if (materialObj.HasProperty("_EmissionMap"))
|
|
{
|
|
var emissionTex = materialObj.GetTexture("_EmissionMap");
|
|
|
|
if (emissionTex != null)
|
|
{
|
|
material.EmissiveTexture = ExportTextureInfo(emissionTex);
|
|
|
|
ExportTextureTransform(material.EmissiveTexture, materialObj, "_EmissionMap");
|
|
|
|
}
|
|
}
|
|
|
|
if (materialObj.HasProperty("_BumpMap"))
|
|
{
|
|
var normalTex = materialObj.GetTexture("_BumpMap");
|
|
|
|
if (normalTex != null)
|
|
{
|
|
material.NormalTexture = ExportNormalTextureInfo(normalTex, materialObj);
|
|
ExportTextureTransform(material.NormalTexture, materialObj, "_BumpMap");
|
|
}
|
|
}
|
|
|
|
switch (materialObj.shader.name)
|
|
{
|
|
case "Standard":
|
|
case "Standard (Roughness setup)":
|
|
case "GLTF/GLTFStandard":
|
|
material.PbrMetallicRoughness = ExportPBRMetallicRoughness(materialObj);
|
|
if (materialObj.HasProperty("_OcclusionMap"))
|
|
{
|
|
var occTex = materialObj.GetTexture("_OcclusionMap");
|
|
if (occTex != null)
|
|
{
|
|
// Pack occlusion with metallicRoughness if any
|
|
if (material.PbrMetallicRoughness.MetallicRoughnessTexture != null)
|
|
{
|
|
var info = new OcclusionTextureInfo();
|
|
if (materialObj.HasProperty("_OcclusionStrength"))
|
|
{
|
|
info.Strength = materialObj.GetFloat("_OcclusionStrength");
|
|
}
|
|
info.Index = material.PbrMetallicRoughness.MetallicRoughnessTexture.Index;
|
|
material.OcclusionTexture = info;
|
|
}
|
|
else
|
|
{
|
|
material.OcclusionTexture = ExportOcclusionTextureInfo(occTex, materialObj);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "Standard (Specular setup)":
|
|
KHR_materials_pbrSpecularGlossinessExtension pbr = convertSpecular(materialObj);
|
|
material.Extensions.Add(KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME, pbr);
|
|
registerExtension(KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME);
|
|
|
|
if (materialObj.HasProperty("_OcclusionMap"))
|
|
{
|
|
var occTex = materialObj.GetTexture("_OcclusionMap");
|
|
if (occTex != null)
|
|
{
|
|
material.OcclusionTexture = ExportOcclusionTextureInfo(occTex, materialObj);
|
|
ExportTextureTransform(material.OcclusionTexture, materialObj, "_OcclusionMap");
|
|
}
|
|
}
|
|
|
|
break;
|
|
case "GLTF/GLTFConstant":
|
|
material.CommonConstant = ExportCommonConstant(materialObj);
|
|
break;
|
|
}
|
|
|
|
_materials.Add(materialObj);
|
|
|
|
id = new MaterialId {
|
|
Id = _root.Materials.Count,
|
|
Root = _root
|
|
};
|
|
_root.Materials.Add(material);
|
|
|
|
return id;
|
|
}
|
|
|
|
private void ExportTextureTransform(TextureInfo def, UnityEngine.Material mat, string texName)
|
|
{
|
|
Vector2 offset = mat.GetTextureOffset(texName);
|
|
Vector2 scale = mat.GetTextureScale(texName);
|
|
|
|
if (offset == Vector2.zero && scale == Vector2.one) return;
|
|
|
|
if (_root.ExtensionsUsed == null)
|
|
{
|
|
_root.ExtensionsUsed = new List<string>(
|
|
new string[] { ExtTextureTransformExtensionFactory.EXTENSION_NAME }
|
|
);
|
|
}
|
|
else if (!_root.ExtensionsUsed.Contains(ExtTextureTransformExtensionFactory.EXTENSION_NAME))
|
|
{
|
|
_root.ExtensionsUsed.Add(ExtTextureTransformExtensionFactory.EXTENSION_NAME);
|
|
}
|
|
|
|
if (def.Extensions == null)
|
|
def.Extensions = new Dictionary<string, Extension>();
|
|
|
|
def.Extensions[ExtTextureTransformExtensionFactory.EXTENSION_NAME] = new ExtTextureTransformExtension(
|
|
new GLTF.Math.Vector2(offset.x, -offset.y),
|
|
new GLTF.Math.Vector2(scale.x, scale.y),
|
|
0 // TODO: support UV channels
|
|
);
|
|
}
|
|
|
|
private void registerExtension(string extension, bool isRequired=false)
|
|
{
|
|
if(!_root.ExtensionsUsed.Contains(extension))
|
|
{
|
|
_root.ExtensionsUsed.Add(extension);
|
|
}
|
|
|
|
if(isRequired && !_root.ExtensionsRequired.Contains(extension))
|
|
{
|
|
_root.ExtensionsRequired.Add(extension);
|
|
}
|
|
}
|
|
|
|
private KHR_materials_pbrSpecularGlossinessExtension convertSpecular(UnityEngine.Material mat)
|
|
{
|
|
GLTF.Math.Color diffuseFactor = mat.GetColor("_Color").ToNumericsColor();
|
|
TextureInfo diffuseTexture = mat.GetTexture("_MainTex") != null ? ExportTextureInfo(mat.GetTexture("_MainTex")) : null;
|
|
|
|
TextureInfo specularGlossinessTexture = null;
|
|
GLTF.Math.Color specularColor = Color.white.ToNumericsColor();
|
|
float glossinessFactor = 1.0f;
|
|
if (mat.GetTexture("_SpecGlossMap"))
|
|
{
|
|
specularGlossinessTexture = ExportTextureInfo(mat.GetTexture("_SpecGlossMap"));
|
|
if(mat.HasProperty("_GlossMapScale"))
|
|
glossinessFactor = mat.GetFloat("_GlossMapScale");
|
|
}
|
|
else
|
|
{
|
|
specularColor = mat.GetColor("_SpecColor").ToNumericsColor();
|
|
if (mat.HasProperty("_Glossiness"))
|
|
glossinessFactor = mat.GetFloat("_Glossiness");
|
|
}
|
|
|
|
GLTF.Math.Vector3 specularFactor = new GLTF.Math.Vector3(specularColor.R, specularColor.G, specularColor.B);
|
|
|
|
|
|
return new KHR_materials_pbrSpecularGlossinessExtension(diffuseFactor, diffuseTexture, specularFactor, glossinessFactor, specularGlossinessTexture);
|
|
}
|
|
|
|
private NormalTextureInfo ExportNormalTextureInfo(UnityEngine.Texture texture, UnityEngine.Material material)
|
|
{
|
|
var info = new NormalTextureInfo();
|
|
info.Index = ExportTexture(_textureCache.handleNormalMap((Texture2D)texture));
|
|
if (material.HasProperty("_BumpScale"))
|
|
{
|
|
info.Scale = material.GetFloat("_BumpScale");
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
private OcclusionTextureInfo ExportOcclusionTextureInfo(UnityEngine.Texture texture, UnityEngine.Material material)
|
|
{
|
|
var info = new OcclusionTextureInfo();
|
|
|
|
info.Index = ExportTexture(texture);
|
|
|
|
if (material.HasProperty("_OcclusionStrength"))
|
|
{
|
|
info.Strength = material.GetFloat("_OcclusionStrength");
|
|
}
|
|
|
|
return info;
|
|
}
|
|
|
|
private PbrMetallicRoughness ExportPBRMetallicRoughness(UnityEngine.Material material)
|
|
{
|
|
var pbr = new PbrMetallicRoughness();
|
|
|
|
if (material.HasProperty("_Color"))
|
|
{
|
|
pbr.BaseColorFactor = material.GetColor("_Color").ToNumericsColor();
|
|
}
|
|
|
|
if (material.HasProperty("_MainTex"))
|
|
{
|
|
var mainTex = material.GetTexture("_MainTex");
|
|
|
|
if (mainTex != null)
|
|
{
|
|
pbr.BaseColorTexture = ExportTextureInfo(mainTex);
|
|
ExportTextureTransform(pbr.BaseColorTexture, material, "_MainTex");
|
|
}
|
|
}
|
|
|
|
if (material.HasProperty("_Metallic"))
|
|
{
|
|
pbr.MetallicFactor = material.GetFloat("_Metallic");
|
|
}
|
|
|
|
if (material.HasProperty("_Roughness"))
|
|
{
|
|
pbr.RoughnessFactor = material.GetFloat("_Roughness");
|
|
}
|
|
else if (material.HasProperty("_Glossiness"))
|
|
{
|
|
pbr.RoughnessFactor = 1.0 - material.GetFloat("_Glossiness");
|
|
}
|
|
|
|
if (material.HasProperty("_MetallicRoughnessMap"))
|
|
{
|
|
var mrTex = material.GetTexture("_MetallicRoughnessMap");
|
|
|
|
if (mrTex != null)
|
|
{
|
|
if (material.HasProperty("_GlossMapScale")) {
|
|
pbr.RoughnessFactor = material.GetFloat("_GlossMapScale");
|
|
}
|
|
|
|
pbr.MetallicRoughnessTexture = ExportTextureInfo(mrTex);
|
|
// writing 1.0 does not export this for whatever reason
|
|
pbr.MetallicFactor = 0.99;
|
|
ExportTextureTransform(pbr.MetallicRoughnessTexture, material, "_MetallicRoughnessMap");
|
|
}
|
|
}
|
|
else if (material.HasProperty("_MetallicGlossMap"))
|
|
{
|
|
var mgTex = material.GetTexture("_MetallicGlossMap") as Texture2D;
|
|
|
|
if (mgTex != null)
|
|
{
|
|
if (material.HasProperty("_GlossMapScale")) {
|
|
pbr.RoughnessFactor = material.GetFloat("_GlossMapScale");
|
|
}
|
|
|
|
var occTex = (material.HasProperty("_OcclusionMap") ? material.GetTexture("_OcclusionMap") as Texture2D : null);
|
|
pbr.MetallicRoughnessTexture = ExportTextureInfo(_textureCache.packOcclusionMetalRough(mgTex, occTex));
|
|
// writing 1.0 does not export this for whatever reason
|
|
pbr.MetallicFactor = 0.99;
|
|
}
|
|
}
|
|
|
|
return pbr;
|
|
}
|
|
|
|
private MaterialCommonConstant ExportCommonConstant(UnityEngine.Material materialObj)
|
|
{
|
|
if (_root.ExtensionsUsed == null)
|
|
{
|
|
_root.ExtensionsUsed = new List<string>(new string[] { "KHR_materials_common" });
|
|
}
|
|
else if(!_root.ExtensionsUsed.Contains("KHR_materials_common"))
|
|
_root.ExtensionsUsed.Add("KHR_materials_common");
|
|
|
|
var constant = new MaterialCommonConstant();
|
|
|
|
if (materialObj.HasProperty("_AmbientFactor"))
|
|
{
|
|
constant.AmbientFactor = materialObj.GetColor("_AmbientFactor").ToNumericsColor();
|
|
}
|
|
|
|
if (materialObj.HasProperty("_LightMap"))
|
|
{
|
|
var lmTex = materialObj.GetTexture("_LightMap");
|
|
|
|
if (lmTex != null)
|
|
{
|
|
constant.LightmapTexture = ExportTextureInfo(lmTex);
|
|
ExportTextureTransform(constant.LightmapTexture, materialObj, "_LightMap");
|
|
}
|
|
|
|
}
|
|
|
|
if (materialObj.HasProperty("_LightFactor"))
|
|
{
|
|
constant.LightmapFactor = materialObj.GetColor("_LightFactor").ToNumericsColor();
|
|
}
|
|
|
|
return constant;
|
|
}
|
|
|
|
private TextureInfo ExportTextureInfo(UnityEngine.Texture texture)
|
|
{
|
|
var info = new TextureInfo();
|
|
|
|
info.Index = ExportTexture(texture);
|
|
|
|
return info;
|
|
}
|
|
|
|
private TextureId ExportTexture(UnityEngine.Texture textureObj)
|
|
{
|
|
TextureId id = GetTextureId(_root, textureObj);
|
|
if (id != null)
|
|
{
|
|
return id;
|
|
}
|
|
|
|
var texture = new GLTF.Schema.Texture();
|
|
|
|
//If texture name not set give it a unique name using count
|
|
if (textureObj.name == "")
|
|
{
|
|
textureObj.name = (_root.Textures.Count + 1).ToString();
|
|
}
|
|
|
|
if (ExportNames)
|
|
{
|
|
texture.Name = textureObj.name;
|
|
}
|
|
|
|
texture.Source = ExportImage(textureObj);
|
|
texture.Sampler = ExportSampler(textureObj);
|
|
|
|
_textures.Add(textureObj);
|
|
|
|
id = new TextureId {
|
|
Id = _root.Textures.Count,
|
|
Root = _root
|
|
};
|
|
|
|
_root.Textures.Add(texture);
|
|
|
|
return id;
|
|
}
|
|
|
|
private ImageId ExportImage(UnityEngine.Texture texture)
|
|
{
|
|
string imagePath = GLTFUtils.buildImageName((Texture2D)texture);
|
|
ImageId id = GetImageId(_root, texture);
|
|
if(id != null)
|
|
{
|
|
return id;
|
|
}
|
|
|
|
var image = new Image();
|
|
|
|
if (ExportNames)
|
|
{
|
|
image.Name = texture.name;
|
|
}
|
|
|
|
_images.Add(texture as Texture2D);
|
|
|
|
image.Uri = imagePath;
|
|
|
|
id = new ImageId {
|
|
Id = _root.Images.Count,
|
|
Root = _root
|
|
};
|
|
|
|
_root.Images.Add(image);
|
|
|
|
return id;
|
|
}
|
|
|
|
private SamplerId ExportSampler(UnityEngine.Texture texture)
|
|
{
|
|
var samplerId = GetSamplerId(_root, texture);
|
|
if (samplerId != null)
|
|
return samplerId;
|
|
|
|
var sampler = new Sampler();
|
|
|
|
if (texture.wrapMode == TextureWrapMode.Clamp)
|
|
{
|
|
sampler.WrapS = GLTF.Schema.WrapMode.ClampToEdge;
|
|
sampler.WrapT = GLTF.Schema.WrapMode.ClampToEdge;
|
|
}
|
|
else
|
|
{
|
|
sampler.WrapS = GLTF.Schema.WrapMode.Repeat;
|
|
sampler.WrapT = GLTF.Schema.WrapMode.Repeat;
|
|
}
|
|
|
|
if(texture.filterMode == FilterMode.Point)
|
|
{
|
|
sampler.MinFilter = MinFilterMode.NearestMipmapNearest;
|
|
sampler.MagFilter = MagFilterMode.Nearest;
|
|
}
|
|
else if(texture.filterMode == FilterMode.Bilinear)
|
|
{
|
|
sampler.MinFilter = MinFilterMode.Linear;
|
|
sampler.MagFilter = MagFilterMode.Linear;
|
|
}
|
|
else
|
|
{
|
|
sampler.MinFilter = MinFilterMode.LinearMipmapLinear;
|
|
sampler.MagFilter = MagFilterMode.Linear;
|
|
}
|
|
|
|
samplerId = new SamplerId
|
|
{
|
|
Id = _root.Samplers.Count,
|
|
Root = _root
|
|
};
|
|
|
|
_root.Samplers.Add(sampler);
|
|
|
|
return samplerId;
|
|
}
|
|
|
|
private Vector2[] FlipY(Vector2[] arr)
|
|
{
|
|
var len = arr.Length;
|
|
for(var i = 0; i < len; i++)
|
|
{
|
|
arr[i].y = 1 - arr[i].y;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
private Vector3[] InvertZ(Vector3[] arr)
|
|
{
|
|
var len = arr.Length;
|
|
for(var i = 0; i < len; i++)
|
|
{
|
|
arr[i].z = -arr[i].z;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
private Vector4[] InvertW(Vector4[] arr)
|
|
{
|
|
var len = arr.Length;
|
|
for(var i = 0; i < len; i++)
|
|
{
|
|
arr[i].w = -arr[i].w;
|
|
}
|
|
return arr;
|
|
}
|
|
|
|
private int[] FlipFaces(int[] arr)
|
|
{
|
|
var triangles = new int[arr.Length];
|
|
for (int i = 0; i < arr.Length; i += 3)
|
|
{
|
|
triangles[i + 2] = arr[i];
|
|
triangles[i + 1] = arr[i + 1];
|
|
triangles[i] = arr[i + 2];
|
|
}
|
|
return triangles;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(int[] arr, bool isIndices = false)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.SCALAR;
|
|
|
|
int min = arr[0];
|
|
int max = arr[0];
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur < min)
|
|
{
|
|
min = cur;
|
|
}
|
|
if (cur > max)
|
|
{
|
|
max = cur;
|
|
}
|
|
}
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
if (_forceIndicesUint)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.UnsignedInt;
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((uint)v);
|
|
|
|
}
|
|
}
|
|
else if (max <= byte.MaxValue && min >= byte.MinValue)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.UnsignedByte;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((byte)v);
|
|
}
|
|
}
|
|
else if (max <= sbyte.MaxValue && min >= sbyte.MinValue && !isIndices)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.Byte;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((sbyte)v);
|
|
}
|
|
}
|
|
else if (max <= short.MaxValue && min >= short.MinValue && !isIndices)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.Short;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((short)v);
|
|
}
|
|
}
|
|
else if (max <= ushort.MaxValue && min >= ushort.MinValue)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.UnsignedShort;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((ushort)v);
|
|
}
|
|
}
|
|
else if (min >= uint.MinValue)
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.UnsignedInt;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((uint)v);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
|
|
foreach (var v in arr)
|
|
{
|
|
_bufferWriter.Write((float)v);
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { min };
|
|
accessor.Max = new List<double> { max };
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(float[] arr)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.SCALAR;
|
|
|
|
float min = arr[0];
|
|
float max = arr[0];
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur < min)
|
|
{
|
|
min = cur;
|
|
}
|
|
if (cur > max)
|
|
{
|
|
max = cur;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { min };
|
|
accessor.Max = new List<double> { max };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var value in arr)
|
|
{
|
|
_bufferWriter.Write(value);
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId
|
|
{
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(Vector2[] arr)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC2;
|
|
|
|
float minX = arr[0].x;
|
|
float minY = arr[0].y;
|
|
float maxX = arr[0].x;
|
|
float maxY = arr[0].y;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.x < minX)
|
|
{
|
|
minX = cur.x;
|
|
}
|
|
if (cur.y < minY)
|
|
{
|
|
minY = cur.y;
|
|
}
|
|
if (cur.x > maxX)
|
|
{
|
|
maxX = cur.x;
|
|
}
|
|
if (cur.y > maxY)
|
|
{
|
|
maxY = cur.y;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minX, minY };
|
|
accessor.Max = new List<double> { maxX, maxY };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var vec in arr) {
|
|
_bufferWriter.Write(vec.x);
|
|
_bufferWriter.Write(vec.y);
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(Vector3[] arr, bool switchHandedness=false)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC3;
|
|
|
|
float minX = arr[0].x;
|
|
float minY = arr[0].y;
|
|
float minZ = arr[0].z;
|
|
float maxX = arr[0].x;
|
|
float maxY = arr[0].y;
|
|
float maxZ = arr[0].z;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.x < minX)
|
|
{
|
|
minX = cur.x;
|
|
}
|
|
if (cur.y < minY)
|
|
{
|
|
minY = cur.y;
|
|
}
|
|
if (cur.z < minZ)
|
|
{
|
|
minZ = cur.z;
|
|
}
|
|
if (cur.x > maxX)
|
|
{
|
|
maxX = cur.x;
|
|
}
|
|
if (cur.y > maxY)
|
|
{
|
|
maxY = cur.y;
|
|
}
|
|
if (cur.z > maxZ)
|
|
{
|
|
maxZ = cur.z;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minX, minY, minZ };
|
|
accessor.Max = new List<double> { maxX, maxY, maxZ };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var vec in arr) {
|
|
if(switchHandedness)
|
|
{
|
|
Vector3 vect = vec.switchHandedness();
|
|
_bufferWriter.Write(vect.x);
|
|
_bufferWriter.Write(vect.y);
|
|
_bufferWriter.Write(vect.z);
|
|
}
|
|
else
|
|
{
|
|
_bufferWriter.Write(vec.x);
|
|
_bufferWriter.Write(vec.y);
|
|
_bufferWriter.Write(vec.z);
|
|
}
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportVerticesAccessor(Vector3[] arr, GameObject parent, bool switchHandedness=false)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC3;
|
|
|
|
if (GLTFUtils.boundsExportOption == GLTFUtils.BoundsExportOption.Default) {
|
|
float minX = arr[0].x;
|
|
float minY = arr[0].y;
|
|
float minZ = arr[0].z;
|
|
float maxX = arr[0].x;
|
|
float maxY = arr[0].y;
|
|
float maxZ = arr[0].z;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.x < minX)
|
|
{
|
|
minX = cur.x;
|
|
}
|
|
if (cur.y < minY)
|
|
{
|
|
minY = cur.y;
|
|
}
|
|
if (cur.z < minZ)
|
|
{
|
|
minZ = cur.z;
|
|
}
|
|
if (cur.x > maxX)
|
|
{
|
|
maxX = cur.x;
|
|
}
|
|
if (cur.y > maxY)
|
|
{
|
|
maxY = cur.y;
|
|
}
|
|
if (cur.z > maxZ)
|
|
{
|
|
maxZ = cur.z;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minX, minY, minZ };
|
|
accessor.Max = new List<double> { maxX, maxY, maxZ };
|
|
}
|
|
else if (GLTFUtils.boundsExportOption == GLTFUtils.BoundsExportOption.SceneViewerFix) {
|
|
Bounds totalBounds = new Bounds();
|
|
|
|
for (var i = 0; i < count; i++) {
|
|
totalBounds.Encapsulate(arr[i]);
|
|
}
|
|
|
|
float pivotX = (totalBounds.min.x + totalBounds.max.x) / 2.0f;
|
|
float pivotY = (totalBounds.min.y + totalBounds.max.y) / 2.0f;
|
|
float pivotZ = (totalBounds.min.z + totalBounds.max.z) / 2.0f;
|
|
|
|
float minX = totalBounds.min.x;
|
|
float minY = totalBounds.min.y;
|
|
float minZ = totalBounds.min.z;
|
|
|
|
float maxX = totalBounds.max.x;
|
|
float maxY = totalBounds.max.y;
|
|
float maxZ = totalBounds.max.z;
|
|
|
|
accessor.Min = new List<double> {minX - pivotX, minY - pivotY, minZ - pivotZ};
|
|
accessor.Max = new List<double> {maxX - pivotX, maxY - pivotY, maxZ - pivotZ};
|
|
}
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var vec in arr) {
|
|
if(switchHandedness)
|
|
{
|
|
Vector3 vect = vec.switchHandedness();
|
|
_bufferWriter.Write(vect.x);
|
|
_bufferWriter.Write(vect.y);
|
|
_bufferWriter.Write(vect.z);
|
|
}
|
|
else
|
|
{
|
|
_bufferWriter.Write(vec.x);
|
|
_bufferWriter.Write(vec.y);
|
|
_bufferWriter.Write(vec.z);
|
|
}
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessorUint(Vector4[] arr)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.UnsignedShort;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC4;
|
|
|
|
float minX = arr[0].x;
|
|
float minY = arr[0].y;
|
|
float minZ = arr[0].z;
|
|
float minW = arr[0].w;
|
|
float maxX = arr[0].x;
|
|
float maxY = arr[0].y;
|
|
float maxZ = arr[0].z;
|
|
float maxW = arr[0].w;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.x < minX)
|
|
{
|
|
minX = cur.x;
|
|
}
|
|
if (cur.y < minY)
|
|
{
|
|
minY = cur.y;
|
|
}
|
|
if (cur.z < minZ)
|
|
{
|
|
minZ = cur.z;
|
|
}
|
|
if (cur.w < minW)
|
|
{
|
|
minW = cur.w;
|
|
}
|
|
if (cur.x > maxX)
|
|
{
|
|
maxX = cur.x;
|
|
}
|
|
if (cur.y > maxY)
|
|
{
|
|
maxY = cur.y;
|
|
}
|
|
if (cur.z > maxZ)
|
|
{
|
|
maxZ = cur.z;
|
|
}
|
|
if (cur.w > maxW)
|
|
{
|
|
maxW = cur.w;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minX, minY, minZ, minW };
|
|
accessor.Max = new List<double> { maxX, maxY, maxZ, maxW };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var vec in arr)
|
|
{
|
|
_bufferWriter.Write((ushort)vec.x);
|
|
_bufferWriter.Write((ushort)vec.y);
|
|
_bufferWriter.Write((ushort)vec.z);
|
|
_bufferWriter.Write((ushort)vec.w);
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId
|
|
{
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(Vector4[] arr, bool switchHandedness=false)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC4;
|
|
|
|
float minX = arr[0].x;
|
|
float minY = arr[0].y;
|
|
float minZ = arr[0].z;
|
|
float minW = arr[0].w;
|
|
float maxX = arr[0].x;
|
|
float maxY = arr[0].y;
|
|
float maxZ = arr[0].z;
|
|
float maxW = arr[0].w;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.x < minX)
|
|
{
|
|
minX = cur.x;
|
|
}
|
|
if (cur.y < minY)
|
|
{
|
|
minY = cur.y;
|
|
}
|
|
if (cur.z < minZ)
|
|
{
|
|
minZ = cur.z;
|
|
}
|
|
if (cur.w < minW)
|
|
{
|
|
minW = cur.w;
|
|
}
|
|
if (cur.x > maxX)
|
|
{
|
|
maxX = cur.x;
|
|
}
|
|
if (cur.y > maxY)
|
|
{
|
|
maxY = cur.y;
|
|
}
|
|
if (cur.z > maxZ)
|
|
{
|
|
maxZ = cur.z;
|
|
}
|
|
if (cur.w > maxW)
|
|
{
|
|
maxW = cur.w;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minX, minY, minZ, minW };
|
|
accessor.Max = new List<double> { maxX, maxY, maxZ, maxW };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var vec in arr) {
|
|
Vector4 vect = switchHandedness ? vec.switchHandedness() : vec;
|
|
_bufferWriter.Write(vect.x);
|
|
_bufferWriter.Write(vect.y);
|
|
_bufferWriter.Write(vect.z);
|
|
_bufferWriter.Write(vect.w);
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(UnityEngine.Color[] arr)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.VEC4;
|
|
|
|
float minR = arr[0].r;
|
|
float minG = arr[0].g;
|
|
float minB = arr[0].b;
|
|
float minA = arr[0].a;
|
|
float maxR = arr[0].r;
|
|
float maxG = arr[0].g;
|
|
float maxB = arr[0].b;
|
|
float maxA = arr[0].a;
|
|
|
|
for (var i = 1; i < count; i++)
|
|
{
|
|
var cur = arr[i];
|
|
|
|
if (cur.r < minR)
|
|
{
|
|
minR = cur.r;
|
|
}
|
|
if (cur.g < minG)
|
|
{
|
|
minG = cur.g;
|
|
}
|
|
if (cur.b < minB)
|
|
{
|
|
minB = cur.b;
|
|
}
|
|
if (cur.a < minA)
|
|
{
|
|
minA = cur.a;
|
|
}
|
|
if (cur.r > maxR)
|
|
{
|
|
maxR = cur.r;
|
|
}
|
|
if (cur.g > maxG)
|
|
{
|
|
maxG = cur.g;
|
|
}
|
|
if (cur.b > maxB)
|
|
{
|
|
maxB = cur.b;
|
|
}
|
|
if (cur.a > maxA)
|
|
{
|
|
maxA = cur.a;
|
|
}
|
|
}
|
|
|
|
accessor.Min = new List<double> { minR, minG, minB, minA };
|
|
accessor.Max = new List<double> { maxR, maxG, maxB, maxA };
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var color in arr) {
|
|
_bufferWriter.Write(color.r);
|
|
_bufferWriter.Write(color.g);
|
|
_bufferWriter.Write(color.b);
|
|
_bufferWriter.Write(color.a);
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId {
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private AccessorId ExportAccessor(Matrix4x4[] arr, bool switchHandedness = false)
|
|
{
|
|
var count = arr.Length;
|
|
|
|
if (count == 0)
|
|
{
|
|
throw new Exception("Accessors can not have a count of 0.");
|
|
}
|
|
|
|
var accessor = new Accessor();
|
|
accessor.ComponentType = GLTFComponentType.Float;
|
|
accessor.Count = count;
|
|
accessor.Type = GLTFAccessorAttributeType.MAT4;
|
|
|
|
// Dont serialize min/max for matrices
|
|
|
|
var byteOffset = _bufferWriter.BaseStream.Position;
|
|
|
|
foreach (var mat in arr)
|
|
{
|
|
Matrix4x4 mamat = switchHandedness ? mat.switchHandedness() : mat;
|
|
for (int i = 0; i < 4; ++i)
|
|
{
|
|
Vector4 col = mamat.GetColumn(i);
|
|
_bufferWriter.Write(col.x);
|
|
_bufferWriter.Write(col.y);
|
|
_bufferWriter.Write(col.z);
|
|
_bufferWriter.Write(col.w);
|
|
}
|
|
}
|
|
|
|
var byteLength = _bufferWriter.BaseStream.Position - byteOffset;
|
|
|
|
accessor.BufferView = ExportBufferView((int)byteOffset, (int)byteLength);
|
|
|
|
var id = new AccessorId
|
|
{
|
|
Id = _root.Accessors.Count,
|
|
Root = _root
|
|
};
|
|
_root.Accessors.Add(accessor);
|
|
|
|
return id;
|
|
}
|
|
|
|
private BufferViewId ExportBufferView(int byteOffset, int byteLength)
|
|
{
|
|
var bufferView = new BufferView {
|
|
Buffer = _bufferId,
|
|
ByteOffset = byteOffset,
|
|
ByteLength = byteLength,
|
|
};
|
|
|
|
var id = new BufferViewId {
|
|
Id = _root.BufferViews.Count,
|
|
Root = _root
|
|
};
|
|
|
|
_root.BufferViews.Add(bufferView);
|
|
|
|
return id;
|
|
}
|
|
|
|
public MaterialId GetMaterialId(GLTFRoot root, UnityEngine.Material materialObj)
|
|
{
|
|
for (var i = 0; i < _materials.Count; i++)
|
|
{
|
|
if (_materials[i] == materialObj)
|
|
{
|
|
return new MaterialId
|
|
{
|
|
Id = i,
|
|
Root = root
|
|
};
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public TextureId GetTextureId(GLTFRoot root, UnityEngine.Texture textureObj)
|
|
{
|
|
for (var i = 0; i < _textures.Count; i++)
|
|
{
|
|
if (_textures[i] == textureObj)
|
|
{
|
|
return new TextureId
|
|
{
|
|
Id = i,
|
|
Root = root
|
|
};
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public ImageId GetImageId(GLTFRoot root, UnityEngine.Texture imageObj)
|
|
{
|
|
for (var i = 0; i < _images.Count; i++)
|
|
{
|
|
if (_images[i] == imageObj)
|
|
{
|
|
return new ImageId
|
|
{
|
|
Id = i,
|
|
Root = root
|
|
};
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public SamplerId GetSamplerId(GLTFRoot root, UnityEngine.Texture textureObj)
|
|
{
|
|
for (var i = 0; i < root.Samplers.Count; i++)
|
|
{
|
|
bool filterIsNearest = root.Samplers[i].MinFilter == MinFilterMode.Nearest
|
|
|| root.Samplers[i].MinFilter == MinFilterMode.NearestMipmapNearest
|
|
|| root.Samplers[i].MinFilter == MinFilterMode.LinearMipmapNearest;
|
|
|
|
bool filterIsLinear = root.Samplers[i].MinFilter == MinFilterMode.Linear
|
|
|| root.Samplers[i].MinFilter == MinFilterMode.NearestMipmapLinear;
|
|
|
|
bool filterMatched = textureObj.filterMode == FilterMode.Point && filterIsNearest
|
|
|| textureObj.filterMode == FilterMode.Bilinear && filterIsLinear
|
|
|| textureObj.filterMode == FilterMode.Trilinear && root.Samplers[i].MinFilter == MinFilterMode.LinearMipmapLinear;
|
|
|
|
bool wrapMatched = textureObj.wrapMode == TextureWrapMode.Clamp && root.Samplers[i].WrapS == GLTF.Schema.WrapMode.ClampToEdge
|
|
|| textureObj.wrapMode == TextureWrapMode.Repeat && root.Samplers[i].WrapS != GLTF.Schema.WrapMode.ClampToEdge;
|
|
|
|
if (filterMatched && wrapMatched)
|
|
{
|
|
return new SamplerId
|
|
{
|
|
Id = i,
|
|
Root = root
|
|
};
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public enum ROTATION_TYPE
|
|
{
|
|
UNKNOWN,
|
|
QUATERNION,
|
|
EULER
|
|
};
|
|
|
|
private struct TargetCurveSet
|
|
{
|
|
public AnimationCurve[] translationCurves;
|
|
public AnimationCurve[] rotationCurves;
|
|
//Additional curve types
|
|
public AnimationCurve[] localEulerAnglesRaw;
|
|
public AnimationCurve[] m_LocalEuler;
|
|
public AnimationCurve[] scaleCurves;
|
|
public ROTATION_TYPE rotationType;
|
|
public void Init()
|
|
{
|
|
translationCurves = new AnimationCurve[3];
|
|
rotationCurves = new AnimationCurve[4];
|
|
scaleCurves = new AnimationCurve[3];
|
|
}
|
|
}
|
|
|
|
static int bakingFramerate = 30; // FPS
|
|
static bool bake = true;
|
|
|
|
// Parses Animation/Animator component and generate a glTF animation for the active clip
|
|
public void exportAnimationFromNode(ref Transform transform/*, ref GLTF.Schema.Animation anim*/)
|
|
{
|
|
Animator a = transform.GetComponent<Animator>();
|
|
|
|
if (a != null) {
|
|
AnimationClip[] clips = AnimationUtility.GetAnimationClips(transform.gameObject);
|
|
|
|
for (int i = 0; i < clips.Length; i++) {
|
|
GLTF.Schema.Animation anim = new GLTF.Schema.Animation();
|
|
anim.Name = GLTFEditorExporter.cleanNonAlphanumeric(a.name);
|
|
convertClipToGLTFAnimation(ref clips[i], ref transform, ref anim);
|
|
|
|
if (anim.Channels.Count > 0 && anim.Samplers.Count > 0) {
|
|
_root.Animations.Add(anim);
|
|
}
|
|
}
|
|
}
|
|
|
|
UnityEngine.Animation animation = transform.GetComponent<UnityEngine.Animation>();
|
|
if (animation != null) {
|
|
foreach (AnimationState state in animation) {
|
|
AnimationClip clip = state.clip;
|
|
|
|
GLTF.Schema.Animation anim = new GLTF.Schema.Animation();
|
|
anim.Name = GLTFEditorExporter.cleanNonAlphanumeric(state.name);
|
|
convertClipToGLTFAnimation(ref clip, ref transform, ref anim);
|
|
|
|
if (anim.Channels.Count > 0 && anim.Samplers.Count > 0) {
|
|
_root.Animations.Add(anim);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private int getTargetIdFromTransform(ref Transform transform)
|
|
{
|
|
if (_exportedTransforms.ContainsKey(transform.GetInstanceID()))
|
|
{
|
|
return _exportedTransforms[transform.GetInstanceID()];
|
|
}
|
|
else
|
|
{
|
|
Debug.Log(transform.name + " " + transform.GetInstanceID());
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
private AccessorId ExportAccessor()
|
|
{
|
|
var id = new AccessorId
|
|
{
|
|
Id = 5,
|
|
Root = _root
|
|
};
|
|
|
|
return id;
|
|
}
|
|
|
|
private void convertClipToGLTFAnimation(ref AnimationClip clip, ref Transform transform, ref GLTF.Schema.Animation animation)
|
|
{
|
|
// Generate GLTF.Schema.AnimationChannel and GLTF.Schema.AnimationSampler
|
|
// 1 channel per node T/R/S, one sampler per node T/R/S
|
|
// Need to keep a list of nodes to convert to indexes
|
|
|
|
// 1. browse clip, collect all curves and create a TargetCurveSet for each target
|
|
Dictionary<string, TargetCurveSet> targetCurvesBinding = new Dictionary<string, TargetCurveSet>();
|
|
collectClipCurves(clip, ref targetCurvesBinding);
|
|
|
|
// Baking needs all properties, fill missing curves with transform data in 2 keyframes (start, endTime)
|
|
// where endTime is clip duration
|
|
// Note: we should avoid creating curves for a property if none of it's components is animated
|
|
generateMissingCurves(clip.length, ref transform, ref targetCurvesBinding);
|
|
|
|
if (bake)
|
|
{
|
|
// Bake animation for all animated nodes
|
|
foreach (string target in targetCurvesBinding.Keys)
|
|
{
|
|
Transform targetTr = target.Length > 0 ? transform.Find(target) : transform;
|
|
if (targetTr == null || targetTr.GetComponent<SkinnedMeshRenderer>())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
|
|
// Initialize data
|
|
// Bake and populate animation data
|
|
float[] times = null;
|
|
Vector3[] positions = null;
|
|
Vector3[] scales = null;
|
|
Vector4[] rotations = null;
|
|
bakeCurveSet(targetCurvesBinding[target], clip.length, bakingFramerate, ref times, ref positions, ref rotations, ref scales);
|
|
|
|
int channelTargetId = getTargetIdFromTransform(ref targetTr);
|
|
AccessorId timeAccessor = ExportAccessor(times);
|
|
|
|
// Create channel
|
|
AnimationChannel Tchannel = new AnimationChannel();
|
|
AnimationChannelTarget TchannelTarget = new AnimationChannelTarget();
|
|
TchannelTarget.Path = GLTFAnimationChannelPath.translation;
|
|
TchannelTarget.Node = new NodeId
|
|
{
|
|
Id = channelTargetId,
|
|
Root = _root
|
|
};
|
|
|
|
Tchannel.Target = TchannelTarget;
|
|
|
|
AnimationSampler Tsampler = new AnimationSampler();
|
|
Tsampler.Input = timeAccessor;
|
|
Tsampler.Output = ExportAccessor(positions, true); // Vec3 for translation
|
|
Tchannel.Sampler = new AnimationSamplerId
|
|
{
|
|
Id = animation.Samplers.Count,
|
|
GLTFAnimation = animation,
|
|
Root = _root
|
|
};
|
|
|
|
animation.Samplers.Add(Tsampler);
|
|
animation.Channels.Add(Tchannel);
|
|
|
|
// Rotation
|
|
AnimationChannel Rchannel = new AnimationChannel();
|
|
AnimationChannelTarget RchannelTarget = new AnimationChannelTarget();
|
|
RchannelTarget.Path = GLTFAnimationChannelPath.rotation;
|
|
RchannelTarget.Node = new NodeId
|
|
{
|
|
Id = channelTargetId,
|
|
Root = _root
|
|
};
|
|
|
|
Rchannel.Target = RchannelTarget;
|
|
|
|
AnimationSampler Rsampler = new AnimationSampler();
|
|
Rsampler.Input = timeAccessor; // Float, for time
|
|
Rsampler.Output = ExportAccessor(rotations, true); // Vec4 for
|
|
Rchannel.Sampler = new AnimationSamplerId
|
|
{
|
|
Id = animation.Samplers.Count,
|
|
GLTFAnimation = animation,
|
|
Root = _root
|
|
};
|
|
|
|
animation.Samplers.Add(Rsampler);
|
|
animation.Channels.Add(Rchannel);
|
|
|
|
// Scale
|
|
AnimationChannel Schannel = new AnimationChannel();
|
|
AnimationChannelTarget SchannelTarget = new AnimationChannelTarget();
|
|
SchannelTarget.Path = GLTFAnimationChannelPath.scale;
|
|
SchannelTarget.Node = new NodeId
|
|
{
|
|
Id = channelTargetId,
|
|
Root = _root
|
|
};
|
|
|
|
Schannel.Target = SchannelTarget;
|
|
|
|
AnimationSampler Ssampler = new AnimationSampler();
|
|
Ssampler.Input = timeAccessor; // Float, for time
|
|
Ssampler.Output = ExportAccessor(scales); // Vec3 for scale
|
|
Schannel.Sampler = new AnimationSamplerId
|
|
{
|
|
Id = animation.Samplers.Count,
|
|
GLTFAnimation = animation,
|
|
Root = _root
|
|
};
|
|
|
|
animation.Samplers.Add(Ssampler);
|
|
animation.Channels.Add(Schannel);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Only baked animation is supported for now. Skipping animation");
|
|
}
|
|
|
|
}
|
|
|
|
private void collectClipCurves(AnimationClip clip, ref Dictionary<string, TargetCurveSet> targetCurves)
|
|
{
|
|
foreach (var binding in UnityEditor.AnimationUtility.GetCurveBindings(clip))
|
|
{
|
|
AnimationCurve curve = AnimationUtility.GetEditorCurve(clip, binding);
|
|
|
|
if (!targetCurves.ContainsKey(binding.path))
|
|
{
|
|
TargetCurveSet curveSet = new TargetCurveSet();
|
|
curveSet.Init();
|
|
targetCurves.Add(binding.path, curveSet);
|
|
}
|
|
|
|
TargetCurveSet current = targetCurves[binding.path];
|
|
if (binding.propertyName.Contains("m_LocalPosition"))
|
|
{
|
|
if (binding.propertyName.Contains(".x"))
|
|
current.translationCurves[0] = curve;
|
|
else if (binding.propertyName.Contains(".y"))
|
|
current.translationCurves[1] = curve;
|
|
else if (binding.propertyName.Contains(".z"))
|
|
current.translationCurves[2] = curve;
|
|
}
|
|
else if (binding.propertyName.Contains("m_LocalScale"))
|
|
{
|
|
if (binding.propertyName.Contains(".x"))
|
|
current.scaleCurves[0] = curve;
|
|
else if (binding.propertyName.Contains(".y"))
|
|
current.scaleCurves[1] = curve;
|
|
else if (binding.propertyName.Contains(".z"))
|
|
current.scaleCurves[2] = curve;
|
|
}
|
|
else if (binding.propertyName.ToLower().Contains("localrotation"))
|
|
{
|
|
current.rotationType = ROTATION_TYPE.QUATERNION;
|
|
if (binding.propertyName.Contains(".x"))
|
|
current.rotationCurves[0] = curve;
|
|
else if (binding.propertyName.Contains(".y"))
|
|
current.rotationCurves[1] = curve;
|
|
else if (binding.propertyName.Contains(".z"))
|
|
current.rotationCurves[2] = curve;
|
|
else if (binding.propertyName.Contains(".w"))
|
|
current.rotationCurves[3] = curve;
|
|
}
|
|
// Takes into account 'localEuler', 'localEulerAnglesBaked' and 'localEulerAnglesRaw'
|
|
else if (binding.propertyName.ToLower().Contains("localeuler"))
|
|
{
|
|
current.rotationType = ROTATION_TYPE.EULER;
|
|
if (binding.propertyName.Contains(".x"))
|
|
current.rotationCurves[0] = curve;
|
|
else if (binding.propertyName.Contains(".y"))
|
|
current.rotationCurves[1] = curve;
|
|
else if (binding.propertyName.Contains(".z"))
|
|
current.rotationCurves[2] = curve;
|
|
}
|
|
targetCurves[binding.path] = current;
|
|
}
|
|
}
|
|
|
|
private void generateMissingCurves(float endTime, ref Transform tr, ref Dictionary<string, TargetCurveSet> targetCurvesBinding)
|
|
{
|
|
foreach (string target in targetCurvesBinding.Keys)
|
|
{
|
|
Transform targetTr = target.Length > 0 ? tr.Find(target) : tr;
|
|
if (targetTr == null)
|
|
continue;
|
|
|
|
TargetCurveSet current = targetCurvesBinding[target];
|
|
if (current.translationCurves[0] == null)
|
|
{
|
|
current.translationCurves[0] = createConstantCurve(targetTr.localPosition.x, endTime);
|
|
current.translationCurves[1] = createConstantCurve(targetTr.localPosition.y, endTime);
|
|
current.translationCurves[2] = createConstantCurve(targetTr.localPosition.z, endTime);
|
|
}
|
|
|
|
if (current.scaleCurves[0] == null)
|
|
{
|
|
current.scaleCurves[0] = createConstantCurve(targetTr.localScale.x, endTime);
|
|
current.scaleCurves[1] = createConstantCurve(targetTr.localScale.y, endTime);
|
|
current.scaleCurves[2] = createConstantCurve(targetTr.localScale.z, endTime);
|
|
}
|
|
|
|
if (current.rotationCurves[0] == null)
|
|
{
|
|
current.rotationCurves[0] = createConstantCurve(targetTr.localRotation.x, endTime);
|
|
current.rotationCurves[1] = createConstantCurve(targetTr.localRotation.y, endTime);
|
|
current.rotationCurves[2] = createConstantCurve(targetTr.localRotation.z, endTime);
|
|
current.rotationCurves[3] = createConstantCurve(targetTr.localRotation.w, endTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
private AnimationCurve createConstantCurve(float value, float endTime)
|
|
{
|
|
// No translation curves, adding them
|
|
AnimationCurve curve = new AnimationCurve();
|
|
curve.AddKey(0, value);
|
|
curve.AddKey(endTime, value);
|
|
return curve;
|
|
}
|
|
|
|
private void bakeCurveSet(TargetCurveSet curveSet, float length, int bakingFramerate, ref float[] times, ref Vector3[] positions, ref Vector4[] rotations, ref Vector3[] scales)
|
|
{
|
|
int nbSamples = (int)(length * 30);
|
|
float deltaTime = length / nbSamples;
|
|
|
|
// Initialize Arrays
|
|
times = new float[nbSamples];
|
|
positions = new Vector3[nbSamples];
|
|
scales = new Vector3[nbSamples];
|
|
rotations = new Vector4[nbSamples];
|
|
|
|
// Assuming all the curves exist now
|
|
for (int i = 0; i < nbSamples; ++i)
|
|
{
|
|
float currentTime = i * deltaTime;
|
|
times[i] = currentTime;
|
|
positions[i] = new Vector3(curveSet.translationCurves[0].Evaluate(currentTime), curveSet.translationCurves[1].Evaluate(currentTime), curveSet.translationCurves[2].Evaluate(currentTime));
|
|
scales[i] = new Vector3(curveSet.scaleCurves[0].Evaluate(currentTime), curveSet.scaleCurves[1].Evaluate(currentTime), curveSet.scaleCurves[2].Evaluate(currentTime));
|
|
if (curveSet.rotationType == ROTATION_TYPE.EULER)
|
|
{
|
|
Quaternion eulerToQuat = Quaternion.Euler(curveSet.rotationCurves[0].Evaluate(currentTime), curveSet.rotationCurves[1].Evaluate(currentTime), curveSet.rotationCurves[2].Evaluate(currentTime));
|
|
rotations[i] = new Vector4(eulerToQuat.x, eulerToQuat.y, eulerToQuat.z, eulerToQuat.w);
|
|
}
|
|
else
|
|
{
|
|
rotations[i] = new Vector4(curveSet.rotationCurves[0].Evaluate(currentTime), curveSet.rotationCurves[1].Evaluate(currentTime), curveSet.rotationCurves[2].Evaluate(currentTime), curveSet.rotationCurves[3].Evaluate(currentTime));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void exportSkinFromNode(Transform transform)
|
|
{
|
|
PrimKey key = new PrimKey();
|
|
UnityEngine.Mesh mesh = getMesh(transform.gameObject);
|
|
key.Mesh = mesh;
|
|
key.Material = getMaterial(transform.gameObject);
|
|
MeshId val;
|
|
if(!_primOwner.TryGetValue(key, out val))
|
|
{
|
|
Debug.Log("No mesh found for skin");
|
|
return;
|
|
}
|
|
SkinnedMeshRenderer skin = transform.GetComponent<SkinnedMeshRenderer>();
|
|
GLTF.Schema.Skin gltfSkin = new Skin();
|
|
|
|
for (int i = 0; i < skin.bones.Length; ++i)
|
|
{
|
|
gltfSkin.Joints.Add(
|
|
new NodeId
|
|
{
|
|
Id = _exportedTransforms[skin.bones[i].GetInstanceID()],
|
|
Root = _root
|
|
});
|
|
}
|
|
|
|
gltfSkin.InverseBindMatrices = ExportAccessor(mesh.bindposes, true);
|
|
|
|
Vector4[] bones = boneWeightToBoneVec4(mesh.boneWeights);
|
|
Vector4[] weights = boneWeightToWeightVec4(mesh.boneWeights);
|
|
|
|
GLTF.Schema.Mesh gltfMesh = _root.Meshes[val.Id];
|
|
foreach(MeshPrimitive prim in gltfMesh.Primitives)
|
|
{
|
|
if(!prim.Attributes.ContainsKey("JOINTS_0"))
|
|
prim.Attributes.Add("JOINTS_0", ExportAccessorUint(bones));
|
|
if (!prim.Attributes.ContainsKey("WEIGHTS_0"))
|
|
prim.Attributes.Add("WEIGHTS_0", ExportAccessor(weights));
|
|
}
|
|
|
|
_root.Nodes[_exportedTransforms[transform.GetInstanceID()]].Skin = new SkinId() { Id = _root.Skins.Count, Root = _root };
|
|
_root.Skins.Add(gltfSkin);
|
|
}
|
|
|
|
private Vector4[] boneWeightToBoneVec4(BoneWeight[] bw)
|
|
{
|
|
Vector4[] bones = new Vector4[bw.Length];
|
|
for (int i = 0; i < bw.Length; ++i)
|
|
{
|
|
bones[i] = new Vector4(bw[i].boneIndex0, bw[i].boneIndex1, bw[i].boneIndex2, bw[i].boneIndex3);
|
|
}
|
|
|
|
return bones;
|
|
}
|
|
|
|
private Vector4[] boneWeightToWeightVec4(BoneWeight[] bw)
|
|
{
|
|
Vector4[] weights = new Vector4[bw.Length];
|
|
for (int i = 0; i < bw.Length; ++i)
|
|
{
|
|
weights[i] = new Vector4(bw[i].weight0, bw[i].weight1, bw[i].weight2, bw[i].weight3);
|
|
}
|
|
|
|
return weights;
|
|
}
|
|
|
|
public static Regex rgx = new Regex("[^a-zA-Z0-9 -_.]");
|
|
|
|
static public string cleanNonAlphanumeric(string s)
|
|
{
|
|
return rgx.Replace(s, "");
|
|
}
|
|
}
|
|
}
|