public bool LoadBVHScene(List <MeshFilter> meshes, out Handle bvhHandle)
{
// filter items
meshes.RemoveAll(delegate(MeshFilter mf)
{
BakeFilter bf = mf.GetComponent <BakeFilter>();
if (bf != null)
{
return(bf.m_bakeFilter == BakeFilter.Filter.ExcludeFromBake);
}
return(false);
});
// find BVH to rebuild
List <MeshFilter> rebuildList = new List <MeshFilter>();
foreach (MeshFilter mf in meshes)
{
if (!IsValidBVH(mf))
{
rebuildList.Add(mf);
}
}
// build BVH for missing/out-of-date BVH's
if (rebuildList.Count > 0)
{
BuildBVH(rebuildList.ToArray());
}
// build id list
IntPtr meshIdsPtr = Alloc(meshes.Count * SIZE_INT);
int[] ids = new int[meshes.Count];
for (int m = 0; m < meshes.Count; ++m)
{
ids[m] = meshes[m].GetUniqueId();
}
CopyArray(meshIdsPtr, meshes.Count * SIZE_INT, ids, meshes.Count * SIZE_INT);
IntPtr[] handle = new IntPtr[1];
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _LoadBVHScene>(meshIdsPtr, meshes.Count, handle);
#else
int err = _LoadBVHScene(meshIdsPtr, meshes.Count, handle);
#endif
Free(meshIdsPtr);
bvhHandle = new Handle(handle[0], this);
if (err != 0)
{
string error = GetLastError();
VertexBakerLib.LogError(error);
return(false);
}
return(true);
}
public int RebuildBVH(BVHHandle bvhHandle)
{
// build baker context
m_baker.m_sourcePaths = new string[] { AssetDatabase.GetAssetPath(bvhHandle.SourceMeshData.sharedMesh) };
m_baker.m_guids = new string[] { "" + m_baker.m_meshes[0].GetUniqueId() };
m_baker.m_meshRenderers = new MeshRenderer[] { bvhHandle.SourceMeshData.GetComponent <MeshRenderer>() };
// parse data and fill in missing context
BakeContext.BuildSceneContext(new MeshFilter[] { bvhHandle.SourceMeshData }, m_baker);
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _RebuildBVH>(bvhHandle.Ptr(), m_baker.m_meshIdsPtr, m_baker.m_vertexCountsPtr, m_baker.m_triangleCountPtr
, m_baker.m_matDataPtr, m_baker.m_meshDataPtr, m_baker.m_triangleDataPtr, m_baker.m_bakeOptionsPtr, 1, m_baker.m_guids, m_baker.m_sourcePaths);
#else
int err = _RebuildBVH(bvhHandle.Ptr(), m_baker.m_meshIdsPtr, m_baker.m_vertexCountsPtr, m_baker.m_triangleCountPtr
, m_baker.m_matDataPtr, m_baker.m_meshDataPtr, m_baker.m_triangleDataPtr, m_baker.m_bakeOptionsPtr, 1, m_baker.m_guids, m_baker.m_sourcePaths);
#endif
m_baker.FreeContext();
if (err != 0)
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
return(err);
}
protected static void TryLoadBVH(MeshFilter meshFilter)
{
if (meshFilter != null && meshFilter.sharedMesh != null)
{
if (!VertexBakerLib.Instance.LoadBVH(meshFilter, ref s_bvhHandle))
{
// Load from scratch
VertexBakerLib.Log("Could not load BVH data, building from scratch");
VertexBakerLib.BVHHandle[] bvhHandles = new VertexBakerLib.BVHHandle[1];
// build BVH and get handle
VertexBakerLib.Instance.BuildBVH(new MeshFilter[] { meshFilter }, ref bvhHandles);
// make sure its good
if (bvhHandles != null && VertexBakerLib.Instance.ValidHandle(bvhHandles[0].Ptr()))
{
s_bvhHandle = bvhHandles[0];
if (VertexBakerLib.s_logging == VertexBakerLib.Logging.kVerbose)
{
VertexBakerLib.Log("BVH build success!");
}
}
else
{
s_bvhHandle = null;
VertexBakerLib.LogError("Invalid BVH Handle, BVH not built");
}
}
}
}
public void BVHToLineSegment(Handle bvhSceneHandle, Vector3 startPoint, Vector3 endPoint, List <Vector3> outCenters, List <Vector3> outSizes)
{
IntPtr[] outCenterSizePtr = new IntPtr[1];
outCenterSizePtr[0] = IntPtr.Zero;
int[] outCount = new int[1];
outCount[0] = 0;
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _BVHToLineSegment>(bvhSceneHandle.Ptr(), startPoint, endPoint, outCenterSizePtr, outCount);
#else
int err = _BVHToLineSegment(bvhSceneHandle.Ptr(), ToFloatArray(startPoint), ToFloatArray(endPoint), outCenterSizePtr, outCount);
#endif
if (err == 0)
{
int count = outCount[0];
IntPtr dataPtr = outCenterSizePtr[0];
if (outCount[0] > 0 && dataPtr != IntPtr.Zero)
{
float[] rawData = new float[outCount[0]];
Marshal.Copy(dataPtr, rawData, 0, outCount[0]);
for (int i = 0; i < count; i += 6)
{
outCenters.Add(new Vector3(rawData[i], rawData[i + 1], rawData[i + 2]));
outSizes.Add(new Vector3(rawData[i + 3], rawData[i + 4], rawData[i + 5]));
}
Free(dataPtr);
}
}
else
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
}
public void GetAsVec2(Mesh mesh, List <int> subMeshIndices, ref Vector2[] outData)
{
VertexElementType elType = (VertexElementType)m_elType;
Vector2[] data = null;
switch (elType)
{
case VertexElementType.kPosition:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kNormal:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kTangent:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kColor:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kUV0:
data = mesh.uv;
break;
case VertexElementType.kUV1:
data = mesh.uv2;
break;
case VertexElementType.kUV2:
data = mesh.uv3;
break;
case VertexElementType.kUV3:
data = mesh.uv4;
break;
default:
VertexBakerLib.LogError("Type Not Supported: " + elType);
outData = null;
break;
}
if (subMeshIndices != null)
{
outData = new Vector2[subMeshIndices.Count];
for (int i = 0, k = subMeshIndices.Count; i < k; ++i)
{
outData[i] = data[subMeshIndices[i]];
}
}
else
{
outData = data;
}
}
public int TessellateTriangles(BVHHandle bvhHandle, Vector3 startPoint, Vector3 endPoint)
{
m_baker.m_sourcePaths = new string[] { AssetDatabase.GetAssetPath(bvhHandle.SourceMeshData.sharedMesh) };
m_baker.m_guids = new string[] { "" + m_baker.m_meshes[0].GetUniqueId() };
m_baker.m_meshRenderers = new MeshRenderer[] { bvhHandle.SourceMeshData.GetComponent <MeshRenderer>() };
List <MeshFilter> meshes = new List <MeshFilter>()
{
bvhHandle.SourceMeshData
};
m_baker.InitBakeContext(meshes, null);
BakeContext.IVertex vertexFormat = new BakeContext.DefaultVertex();
BakeContext.BuildSceneContext(m_baker.m_meshes.ToArray(), m_baker, vertexFormat);
int[] outIndex = new int[1];
outIndex[0] = -1;
#if DDR_RUNTIME_DLL_LINKING_
bool success = Invoke <bool, _TessellateTriangles>(bvhHandle.Ptr()
, m_baker.m_meshIdsPtr
, m_baker.m_vertexCountsPtr
, m_baker.m_triangleCountPtr
, vertexFormat.ElementCount
, vertexFormat.Definition.ToArray()
, m_baker.m_matDataPtr
, m_baker.m_meshDataPtr
, m_baker.m_triangleDataPtr
, m_baker.m_bakeOptionsPtr
, m_baker.m_guids
, m_baker.m_sourcePaths
, m_baker.m_settingsPtrs);
#else
bool success = _TessellateTriangles(bvhHandle.Ptr()
, m_baker.m_meshIdsPtr
, m_baker.m_vertexCountsPtr
, m_baker.m_triangleCountPtr
, vertexFormat.ElementCount
, vertexFormat.Definition.ToArray()
, m_baker.m_matDataPtr
, m_baker.m_meshDataPtr
, m_baker.m_triangleDataPtr
, m_baker.m_bakeOptionsPtr
, m_baker.m_guids
, m_baker.m_sourcePaths
, m_baker.m_settingsPtrs);
#endif
if (!success)
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
return(outIndex[0]);
}
public int CopyVector4(IntPtr dest, int destSize, Vector4 src, int byteCount)
{
#if DDR_RUNTIME_DLL_LINKING_
int errno = Invoke <int, _CopyVector4>(dest, destSize, src, byteCount);
#else
int errno = _CopyVector4(dest, destSize, ref src, byteCount);
#endif
if (errno != 0)
{
VertexBakerLib.LogError("Error copying data in memcpy_s, errno " + errno);
}
return(errno == 0 ? byteCount : 0);
}
public IntPtr Alloc(int size)
{
#if DDR_RUNTIME_DLL_LINKING_
IntPtr ptr = Invoke <IntPtr, _Alloc>(size);
#else
IntPtr ptr = _Alloc(size);
#endif
if (ptr == IntPtr.Zero)
{
VertexBakerLib.LogError("Alloc null");
}
return(ptr);
}
public void TestFileSystem()
{
#if DDR_RUNTIME_DLL_LINKING_
bool pass = Invoke <bool, _TestFileSystem>();
#else
bool pass = _TestFileSystem();
#endif
if (!pass)
{
VertexBakerLib.LogError("TestFileSystem failed");
}
else
{
VertexBakerLib.Log("TestFileSystem pass");
}
}
public bool LoadBVH(MeshFilter mesh, ref BVHHandle bvhHandle)
{
IntPtr[] handle = new IntPtr[1];
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _LoadBVH>(mesh.GetUniqueId(), handle);
#else
int err = _LoadBVH(mesh.GetUniqueId(), handle);
#endif
bvhHandle = new BVHHandle(mesh, handle[0], this);
if (err != 0)
{
string error = GetLastError();
VertexBakerLib.LogError(error);
return(false);
}
return(true);
}
public int RayToIndex(Handle bvhSceneHandle, Vector3 startPoint, Vector3 endPoint)
{
int[] outIndex = new int[1];
outIndex[0] = -1;
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _RayToIndex>(bvhSceneHandle.Ptr(), ToFloatArray(startPoint), ToFloatArray(endPoint), outIndex);
#else
int err = _RayToIndex(bvhSceneHandle.Ptr(), ToFloatArray(startPoint), ToFloatArray(endPoint), outIndex);
#endif
if (err != 0)
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
return(outIndex[0]);
}
public void GetAsColor(Mesh mesh, List <int> subMeshIndices, ref Color[] outData)
{
Color[] data = null;
VertexElementType elType = (VertexElementType)m_elType;
switch (elType)
{
case VertexElementType.kPosition:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kNormal:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kTangent:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kColor:
data = mesh.colors;
break;
case VertexElementType.kUV0:
case VertexElementType.kUV1:
case VertexElementType.kUV2:
case VertexElementType.kUV3:
default:
VertexBakerLib.LogError("Type Not Supported: " + elType);
data = null;
break;
}
if (subMeshIndices != null)
{
outData = new Color[subMeshIndices.Count];
for (int i = 0, k = subMeshIndices.Count; i < k; ++i)
{
outData[i] = data[subMeshIndices[i]];
}
}
else
{
outData = data;
};
}
public void OccludersAtVertex(Handle bvhhandle, int vertIndex, Vector3 worldPos, Vector3 worldNorm
, ref List <Vector3> testPoints, ref List <Vector3> colPoints, ref float accessability, ref Vector3 accumulatedRayDir)
{
// dest points data
IntPtr[] testPointsPtr = new IntPtr[1];
int[] testPointCount = new int[1];
testPointsPtr[0] = IntPtr.Zero;
testPointCount[0] = 0;
// col Points data
IntPtr[] colPointsPtr = new IntPtr[1];
int[] colCount = new int[1];
colPointsPtr[0] = IntPtr.Zero;
colCount[0] = 0;
// data to hold accessability
float[] accessabilityOut = new float[1] {
0f
};
// data to hold accumulated ray dir
Vector3[] accumulatedRayDirOut = new Vector3[1] {
Vector3.zero
};
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _OccludersAtVertex>(bvhhandle.Ptr(), vertIndex, worldPos, worldNorm, testPointsPtr, testPointCount, colPointsPtr, colCount, accessabilityOut, accumulatedRayDirOut);
#else
int err = _OccludersAtVertex(bvhhandle.Ptr(), vertIndex, worldPos, worldNorm, testPointsPtr, testPointCount, colPointsPtr, colCount, accessabilityOut, accumulatedRayDirOut);
#endif
if (err == 0)
{
CopyFloatPtrToVectorList(testPointsPtr[0], testPointCount[0], ref testPoints);
CopyFloatPtrToVectorList(colPointsPtr[0], colCount[0], ref colPoints);
accessability = accessabilityOut[0];
accumulatedRayDir = accumulatedRayDirOut[0];
}
else
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
}
public void LightBlockersAtVertex(Handle bvhhandle, int vertIndex, Vector3 worldPos, Vector3 worldNorm, Vector3 worldLightPos, Vector3 worldLightDir,
Vector3 lightColor, Vector4 lightRIAT, ref List <Vector3> outStartPoints, ref List <Vector3> outEndPoints, ref List <Vector3> outColPoints)
{
IntPtr[] startPoints = new IntPtr[1];
IntPtr[] endPoints = new IntPtr[1];
int[] pointCount = new int[1];
startPoints[0] = IntPtr.Zero;
endPoints[0] = IntPtr.Zero;
pointCount[0] = 0;
IntPtr[] colPoints = new IntPtr[1];
int[] colCount = new int[1];
colPoints[0] = IntPtr.Zero;
colCount[0] = 0;
#if DDR_RUNTIME_DLL_LINKING_
int err = Invoke <int, _LightBlockersAtVertex>(bvhhandle.Ptr(), vertIndex, worldPos, worldNorm, worldLightPos, worldLightDir
, lightColor, lightRIAT, startPoints, endPoints, pointCount, colPoints, colCount);
#else
float[] wPosArr = ToFloatArray(worldPos);
float[] wNormArr = ToFloatArray(worldNorm);
float[] wLightPosArr = ToFloatArray(worldLightPos);
float[] wLightDirArr = ToFloatArray(worldLightDir);
float[] lightColorArr = ToFloatArray(lightColor);
float[] lightRIATArr = ToFloatArray(lightRIAT);
int err = _LightBlockersAtVertex(bvhhandle.Ptr(), vertIndex, wPosArr, wNormArr, wLightPosArr, wLightDirArr
, lightColorArr, lightRIATArr, startPoints, endPoints, pointCount, colPoints, colCount);
#endif
if (err == 0)
{
CopyFloatPtrToVectorList(startPoints[0], pointCount[0], ref outStartPoints);
CopyFloatPtrToVectorList(endPoints[0], pointCount[0], ref outEndPoints);
CopyFloatPtrToVectorList(colPoints[0], colCount[0], ref outColPoints);
}
else
{
string error = GetLastError();
VertexBakerLib.LogError(error);
}
}
public void Bake()
{
try
{
#if DDR_RUNTIME_DLL_LINKING_
m_result = VertexBakerLib.Instance.InvokeAsync <int, _Bake>(m_meshIdsPtr, m_vertexCountsPtr, m_triangleCountPtr, m_matDataPtr
, m_meshDataPtr, m_triangleDataPtr, m_bakeOptionsPtr, m_layerPtr, m_meshCount, m_vertexEementCount, m_vertexDefinition, m_guids
, m_sourcePaths, m_settingsIndicesPtr, m_settingsPtrs, m_lightsDataPtr, m_lightsOptPtr
, m_lightCount, m_outBasis0, m_outBasis1, m_outBasis2);
#else
m_result = _Bake(m_meshIdsPtr, m_vertexCountsPtr, m_triangleCountPtr, m_matDataPtr
, m_meshDataPtr, m_triangleDataPtr, m_bakeOptionsPtr, m_layerPtr, m_meshCount, m_vertexEementCount, m_vertexDefinition, m_guids
, m_sourcePaths, m_settingsIndicesPtr, m_settingsPtrs, m_lightsDataPtr, m_lightsOptPtr
, m_lightCount, m_outBasis0, m_outBasis1, m_outBasis2);
#endif
m_run = false;
m_callback();
}
catch (Exception e)
{
VertexBakerLib.LogError(e.Message);
VertexBakerLib.LogError(e.StackTrace);
}
}
public int BakeFinish(OnFinishedUpdate onUpdate)
{
VertexBakerLib.Assert(this != null && !m_run, "BakeFinished called but bake is still in process");
string outputPath = BakeData.DataPath;
if (!Directory.Exists(outputPath))
{
Directory.CreateDirectory(outputPath);
}
if (m_result != 0)
{
string error = VertexBakerLib.Instance.GetLastError();
VertexBakerLib.LogError(error);
}
else if (!m_cancel && m_outBasis0[0] != IntPtr.Zero && m_outBasis1[0] != IntPtr.Zero && m_outBasis2[0] != IntPtr.Zero)
{
string bakeSetId = BakeData.Instance().GetBakeSettings().SelectedBakeSet.m_settingsId;
BakeSets bakeSets = BakeData.Instance().GetBakeSets();
MeshContainer meshContainer = BakeData.Instance().GetMeshContainer(bakeSetId);
EditorUtility.SetDirty(meshContainer);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
AssetDatabase.StartAssetEditing();
try
{
int ptrOffset = 0;
int meshOffset = 0;
for (int m = 0; m < m_meshes.Count; ++m)
{
int count = m_vertCounts[m];
int floatCount = count * 3;
// the ID used to look up this mesh later
string objectId = "" + m_lightBakers[m].GetUniqueId();
m_lightBakers[m].m_currentContainer = meshContainer;
Mesh outputMesh = meshContainer.m_list.Find(delegate(Mesh mesh)
{
if (mesh != null)
{
return(mesh.name == bakeSetId + "_" + objectId);
}
return(false);
});
if (outputMesh == null)
{
if (m_lightBakers[m].VertexLighting != null)
{
// if we are here than the mesh name may have changed, try and remove the stale data
string oldName = m_lightBakers[m].VertexLighting.name;
Mesh found = meshContainer.m_list.Find(delegate(Mesh mesh)
{
// remove the old reference
if (mesh != null)
{
return(mesh.name == oldName);
}
// remove null mesh
return(false);
});
if (found != null)
{
GameObject.DestroyImmediate(found, true);
}
}
// if no mesh exists for this target create it here
outputMesh = new Mesh();
BakeData.Instance().AddToMeshContainer(meshContainer, outputMesh);
//meshContainer.m_list.Add(outputMesh);
//// add to the container asset
//string outputFileName = bakeSetId + "_lighting";
//AssetDatabase.AddObjectToAsset(outputMesh, outputPath + "/" + outputFileName + ".asset");
}
outputMesh.name = bakeSetId + "_" + objectId;
// HACK: Work around to make Unity happy. If vertices are not found the additional vertex stream fails
//outMeshes[m].vertices = m_meshes[m].sharedMesh.vertices;
outputMesh.vertices = m_meshes[m].sharedMesh.vertices;
// 3 floats per vector
float[] rawData0 = new float[floatCount];
float[] rawData1 = new float[floatCount];
float[] rawData2 = new float[floatCount];
// offset pointer to next mesh
IntPtr basis0 = new IntPtr(m_outBasis0[0].ToInt64() + ptrOffset * SIZE_FLOAT);
IntPtr basis1 = new IntPtr(m_outBasis1[0].ToInt64() + ptrOffset * SIZE_FLOAT);
IntPtr basis2 = new IntPtr(m_outBasis2[0].ToInt64() + ptrOffset * SIZE_FLOAT);
ptrOffset += floatCount;
// marshal data into float arrays
Marshal.Copy(basis0, rawData0, 0, floatCount);
Marshal.Copy(basis1, rawData1, 0, floatCount);
Marshal.Copy(basis2, rawData2, 0, floatCount);
// lists to hold output vectors
List <Color> colorList0 = new List <Color>();
colorList0.Resize(count, Color.black);
List <Vector3> colorList1 = new List <Vector3>();
colorList1.Resize(count, Vector3.zero);
List <Vector3> colorList2 = new List <Vector3>();
colorList2.Resize(count, Vector3.zero);
// copy float arrays into mesh data
for (int i = 0; i < count; ++i)
{
int idx = i * 3;
colorList0[i] = new Color(rawData0[idx], rawData0[idx + 1], rawData0[idx + 2], 1.0f);
colorList1[i] = new Vector3(rawData1[idx], rawData1[idx + 1], rawData1[idx + 2]);
colorList2[i] = new Vector3(rawData2[idx], rawData2[idx + 1], rawData2[idx + 2]);
}
// this offset is target uv sets 1, 2, and 3 for data destination
const int uvOffset = 1;
outputMesh.SetColors(colorList0);
outputMesh.SetUVs(uvOffset + 1, colorList1);
outputMesh.SetUVs(uvOffset + 2, colorList2);
//outputMesh.UploadMeshData(true);
meshOffset += count;
EditorUtility.SetDirty(meshContainer);
m_meshRenderers[m].additionalVertexStreams = outputMesh;
m_lightBakers[m].m_bakeSets = bakeSets;
m_lightBakers[m].VertexLighting = outputMesh;
m_lightBakers[m].m_bakeId = objectId;
EditorUtility.SetDirty(m_lightBakers[m]);
onUpdate("Uploading Mesh Data", m_meshCount / (float)m);
}
// remove any null slots
meshContainer.m_list.RemoveAll(delegate(Mesh m)
{
return(m == null);
});
// aggregate containers under one super container
int existingIdx = bakeSets.m_containers.FindIndex(delegate(MeshContainer mc) { return(mc.name == meshContainer.name); });
if (existingIdx != -1)
{
// replace existing entry
bakeSets.m_containers[existingIdx] = meshContainer;
}
else
{
bakeSets.m_containers.Add(meshContainer);
}
BakeSetsInspector.CleanupStaleReferences(bakeSets);
EditorUtility.SetDirty(bakeSets);
AssetDatabase.SaveAssets();
}
finally
{
onUpdate("Uploading Mesh Data", 1f);
AssetDatabase.StopAssetEditing();
}
}
else
{
VertexBakerLib.LogWarning("Bake completed successfully but there was no output data available");
}
// free data
FreeContext(true);
// since basis memory was allocated in one chunk
// freeing this handle frees all basis memory
VertexBakerLib.Instance.Free(m_outBasis0[0]);
EditorSceneManager.MarkSceneDirty(EditorSceneManager.GetActiveScene());
EditorSceneManager.SaveScene(EditorSceneManager.GetActiveScene());
VertexBakerLib.Log("Bake time: " + (DateTime.Now - m_bakeStart).TotalSeconds + " seconds");
while (VertexBakerLib.Instance.GetErrorCount() > 0)
{
string err = VertexBakerLib.Instance.GetLastError();
VertexBakerLib.LogError(err);
}
GC.Collect();
return(m_result);
}
public void GetAsVec4(Mesh mesh, List <int> subMeshIndices, ref Vector4[] outData)
{
Vector4[] data = null;
VertexElementType elType = (VertexElementType)m_elType;
switch (elType)
{
case VertexElementType.kPosition:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kNormal:
VertexBakerLib.LogError("Type Not Supported: " + elType);
break;
case VertexElementType.kTangent:
data = mesh.tangents;
break;
case VertexElementType.kColor:
case VertexElementType.kUV0:
{
List <Vector4> v = new List <Vector4>();
mesh.GetUVs(0, v);
data = v.ToArray();
break;
}
case VertexElementType.kUV1:
{
List <Vector4> v = new List <Vector4>();
mesh.GetUVs(1, v);
data = v.ToArray();
break;
}
case VertexElementType.kUV2:
{
List <Vector4> v = new List <Vector4>();
mesh.GetUVs(2, v);
data = v.ToArray();
break;
}
case VertexElementType.kUV3:
{
List <Vector4> v = new List <Vector4>();
mesh.GetUVs(3, v);
data = v.ToArray();
break;
}
default:
VertexBakerLib.LogError("Type Not Supported: " + elType);
data = null;
break;
}
if (subMeshIndices != null)
{
outData = new Vector4[subMeshIndices.Count];
for (int i = 0, k = subMeshIndices.Count; i < k; ++i)
{
outData[i] = data[subMeshIndices[i]];
}
}
else
{
outData = data;
}
}
