/// <summary>
/// Get number of components of glTF attribute type.
/// </summary>
/// <param name="type">glTF attribute type</param>
/// <returns>Number of components</returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
public static int GetAccessorAttributeTypeLength(GLTFAccessorAttributeType type)
{
switch (type)
{
case GLTFAccessorAttributeType.SCALAR:
return(1);
case GLTFAccessorAttributeType.VEC2:
return(2);
case GLTFAccessorAttributeType.VEC3:
return(3);
case GLTFAccessorAttributeType.VEC4:
case GLTFAccessorAttributeType.MAT2:
return(4);
case GLTFAccessorAttributeType.MAT3:
return(9);
case GLTFAccessorAttributeType.MAT4:
return(16);
default:
throw new ArgumentOutOfRangeException(nameof(type), type, null);
}
}
public static int GetAccessorAttriuteTypeLength(GLTFAccessorAttributeType type)
{
switch (type)
{
case GLTFAccessorAttributeType.SCALAR:
return(1);
case GLTFAccessorAttributeType.VEC2:
return(2);
case GLTFAccessorAttributeType.VEC3:
return(3);
case GLTFAccessorAttributeType.VEC4:
case GLTFAccessorAttributeType.MAT2:
return(4);
case GLTFAccessorAttributeType.MAT3:
return(9);
case GLTFAccessorAttributeType.MAT4:
return(16);
default:
Debug.LogError("Unknown GLTFAccessorAttributeType");
return(0);
}
}
public Accessor(Accessor accessor, GLTFRoot gltfRoot) : base(accessor, gltfRoot)
{
if (accessor == null)
{
return;
}
if (accessor.BufferView != null)
{
BufferView = new BufferViewId(accessor.BufferView, gltfRoot);
}
ByteOffset = accessor.ByteOffset;
ComponentType = accessor.ComponentType;
Normalized = accessor.Normalized;
Count = accessor.Count;
Type = accessor.Type;
if (accessor.Max != null)
{
Max = accessor.Max.ToList();
}
if (accessor.Min != null)
{
Min = accessor.Min.ToList();
}
if (accessor.Sparse != null)
{
Sparse = new AccessorSparse(accessor.Sparse, gltfRoot);
}
}
static Type GetAccessorTye(GLTFAccessorAttributeType accessorAttributeType)
{
switch (accessorAttributeType)
{
case GLTFAccessorAttributeType.SCALAR:
return(typeof(float));
case GLTFAccessorAttributeType.VEC2:
return(typeof(Vector2));
case GLTFAccessorAttributeType.VEC3:
return(typeof(Vector3));
case GLTFAccessorAttributeType.VEC4:
case GLTFAccessorAttributeType.MAT2:
return(typeof(Vector4));
case GLTFAccessorAttributeType.MAT3:
return(typeof(Matrix4x4));
case GLTFAccessorAttributeType.MAT4:
default:
Debug.LogError("Unknown/Unsupported GLTFAccessorAttributeType");
return(typeof(float));
}
}
private static void TestAccessor(Accessor accessor, GLTFAccessorAttributeType type, int count, GLTFComponentType componentType, int bufferViewId, List <float> max, List <float> min)
{
Assert.AreEqual(type, accessor.Type);
Assert.AreEqual(count, accessor.Count);
Assert.AreEqual(componentType, accessor.ComponentType);
Assert.AreEqual(bufferViewId, accessor.BufferView.Id);
Assert.AreEqual(min.Count, accessor.Min.Count);
Assert.AreEqual(max.Count, accessor.Max.Count);
for (int i = 0; i < max.Count; ++i)
{
Assert.AreEqual(max[i], accessor.Max[i], .000001f);
}
for (int i = 0; i < min.Count; ++i)
{
Assert.AreEqual(min[i], accessor.Min[i], .000001f);
}
}
public static Accessor PackToBufferFloatArray(
MemoryStream stream, float[] data,
GLTFAccessorAttributeType attributeType,
GLTFComponentType componentType
)
{
var accessor = new Accessor();
accessor.ByteOffset = (int)stream.Length;
accessor.ComponentType = componentType;
accessor.Type = attributeType;
int elementSize = attributeType == GLTFAccessorAttributeType.VEC2 ? 2 : attributeType == GLTFAccessorAttributeType.VEC3 ? 3 : attributeType == GLTFAccessorAttributeType.VEC4 ? 4 : 1;
// no need to calc max and min for animation
var bytes = GetBytes(data, componentType);
stream.Write(bytes, 0, bytes.Length);
accessor.Count = data.Length / elementSize;
return(accessor);
}
private static byte[] GetDataToBuffer <DataType>(
DataType value, GLTFComponentType componentType,
ref double[] max, ref double[] min, ref GLTFAccessorAttributeType type
)
{
float[] array = null;
int[] intArray = null;
int size = 0;
/**
* @todo: support int uint short byte ushort...
*/
if (typeof(DataType) == typeof(float))
{
size = 1;
type = GLTFAccessorAttributeType.SCALAR;
var v = (float)Convert.ChangeType(value, typeof(float));
array = new float[] { v };
}
else if (typeof(DataType) == typeof(int))
{
size = 1;
type = GLTFAccessorAttributeType.SCALAR;
var v = (int)Convert.ChangeType(value, typeof(int));
intArray = new int[] { v };
}
else if (typeof(DataType) == typeof(Vector2))
{
size = 2;
type = GLTFAccessorAttributeType.VEC2;
var v = (Vector2)Convert.ChangeType(value, typeof(Vector2));
array = new float[] { v.x, v.y };
}
else if (typeof(DataType) == typeof(Vector3))
{
size = 3;
type = GLTFAccessorAttributeType.VEC3;
var v = (Vector3)Convert.ChangeType(value, typeof(Vector3));
array = new float[] { v.x, v.y, v.z };
}
else if (typeof(DataType) == typeof(Vector4))
{
size = 4;
type = GLTFAccessorAttributeType.VEC4;
var v = (Vector4)Convert.ChangeType(value, typeof(Vector4));
array = new float[] { v.x, v.y, v.z, v.w };
}
else if (typeof(DataType) == typeof(Color))
{
size = 4;
type = GLTFAccessorAttributeType.VEC4;
var v = (Color)Convert.ChangeType(value, typeof(Color));
array = new float[] { v.r, v.g, v.b, v.a };
}
else if (typeof(DataType) == typeof(BoneWeight))
{
size = 4;
type = GLTFAccessorAttributeType.VEC4;
var v = (BoneWeight)Convert.ChangeType(value, typeof(BoneWeight));
intArray = new int[] { v.boneIndex0, v.boneIndex1, v.boneIndex2, v.boneIndex3 };
}
else if (typeof(DataType) == typeof(Matrix4x4))
{
size = 16;
type = GLTFAccessorAttributeType.MAT4;
var v = (Matrix4x4)Convert.ChangeType(value, typeof(Matrix4x4));
array = new float[] {
v.m00, v.m10, v.m20, v.m30,
v.m01, v.m11, v.m21, v.m31,
v.m02, v.m12, v.m22, v.m32,
v.m03, v.m13, v.m23, v.m33
};
}
else
{
Utils.ThrowExcption("Only support packing float, int, Vector2, Vector3, Vector4, BoneWeight, Matrix4 and Color now !");
}
if (max == null)
{
max = new double[size];
min = new double[size];
for (int i = 0; i < size; i += 1)
{
var v = intArray == null ? array[i] : intArray[i];
max[i] = v;
min[i] = v;
}
}
for (int i = 0; i < size; i += 1)
{
var v = intArray == null ? array[i] : intArray[i];
max[i] = max[i] > v ? max[i] : v;
min[i] = min[i] < v ? min[i] : v;
}
if (intArray != null)
{
return(GetBytes(intArray, componentType));
}
return(GetBytes(array, componentType));
}
unsafe JobHandle?GetColors32Job(
void *input,
GLTFComponentType inputType,
GLTFAccessorAttributeType attributeType,
int inputByteStride,
NativeArray <float4> output
)
{
Profiler.BeginSample("PrepareColors32");
JobHandle?jobHandle = null;
if (attributeType == GLTFAccessorAttributeType.VEC3)
{
switch (inputType)
{
case GLTFComponentType.UnsignedByte:
{
var job = new Jobs.ConvertColorsRGBUInt8ToRGBAFloatJob {
input = (byte *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 3,
result = output
};
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
}
break;
case GLTFComponentType.Float:
{
var job = new Jobs.ConvertColorsRGBFloatToRGBAFloatJob {
input = (byte *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 12,
result = (float4 *)output.GetUnsafePtr()
};
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
}
break;
case GLTFComponentType.UnsignedShort:
{
var job = new Jobs.ConvertColorsRGBUInt16ToRGBAFloatJob {
input = (System.UInt16 *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 6,
result = output
};
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
}
break;
default:
logger?.Error(LogCode.ColorFormatUnsupported, attributeType.ToString());
break;
}
}
else if (attributeType == GLTFAccessorAttributeType.VEC4)
{
switch (inputType)
{
case GLTFComponentType.UnsignedByte:
{
var job = new Jobs.ConvertColorsRGBAUInt8ToRGBAFloatJob {
input = (byte *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 4,
result = output
};
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
}
break;
case GLTFComponentType.Float:
{
if (inputByteStride == 16 || inputByteStride <= 0)
{
var job = new Jobs.MemCopyJob {
bufferSize = output.Length * 16,
input = input,
result = output.GetUnsafeReadOnlyPtr()
};
jobHandle = job.Schedule();
}
else
{
var job = new Jobs.ConvertColorsRGBAFloatToRGBAFloatJob {
input = (byte *)input,
inputByteStride = inputByteStride,
result = (float4 *)output.GetUnsafePtr()
};
#if UNITY_JOBS
jobHandle = job.ScheduleBatch(output.Length, GltfImport.DefaultBatchCount);
#else
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
#endif
}
}
break;
case GLTFComponentType.UnsignedShort:
{
var job = new Jobs.ConvertColorsRGBAUInt16ToRGBAFloatJob {
input = (System.UInt16 *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 8,
result = (float4 *)output.GetUnsafePtr()
};
#if UNITY_JOBS
jobHandle = job.ScheduleBatch(output.Length, GltfImport.DefaultBatchCount);
#else
jobHandle = job.Schedule(output.Length, GltfImport.DefaultBatchCount);
#endif
}
break;
default:
logger?.Error(LogCode.ColorFormatUnsupported, attributeType.ToString());
break;
}
}
else
{
logger?.Error(LogCode.TypeUnsupported, "color accessor", inputType.ToString());
}
Profiler.EndSample();
return(jobHandle);
}
unsafe JobHandle?GetColors32Job(
void *input,
GLTFComponentType inputType,
GLTFAccessorAttributeType attributeType,
int inputByteStride,
NativeArray <Color> output
)
{
Profiler.BeginSample("PrepareColors32");
JobHandle?jobHandle = null;
if (attributeType == GLTFAccessorAttributeType.VEC3)
{
switch (inputType)
{
case GLTFComponentType.UnsignedByte:
{
var job = new Jobs.GetColorsVec3UInt8Job {
input = (byte *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 3,
result = output
};
jobHandle = job.Schedule(output.Length, GLTFast.DefaultBatchCount);
}
break;
case GLTFComponentType.Float:
{
var job = new Jobs.GetColorsVec3FloatJob {
input = (float *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 12,
result = output
};
jobHandle = job.Schedule(output.Length, GLTFast.DefaultBatchCount);
}
break;
case GLTFComponentType.UnsignedShort:
{
var job = new Jobs.GetColorsVec3UInt16Job {
input = (System.UInt16 *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 6,
result = output
};
jobHandle = job.Schedule(output.Length, GLTFast.DefaultBatchCount);
}
break;
default:
Debug.LogErrorFormat(GLTFast.ErrorUnsupportedColorFormat, attributeType);
break;
}
}
else if (attributeType == GLTFAccessorAttributeType.VEC4)
{
switch (inputType)
{
case GLTFComponentType.UnsignedByte:
{
var job = new Jobs.GetColorsVec4UInt8Job {
input = (byte *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 4,
result = output
};
jobHandle = job.Schedule(output.Length, GLTFast.DefaultBatchCount);
}
break;
case GLTFComponentType.Float:
{
var job = new Jobs.MemCopyJob();
job.bufferSize = output.Length * 16;
job.input = input;
job.result = NativeArrayUnsafeUtility.GetUnsafeReadOnlyPtr(output);
jobHandle = job.Schedule();
}
break;
case GLTFComponentType.UnsignedShort:
{
var job = new Jobs.GetColorsVec4UInt16Job {
input = (System.UInt16 *)input,
inputByteStride = inputByteStride > 0 ? inputByteStride : 8,
result = output
};
jobHandle = job.Schedule(output.Length, GLTFast.DefaultBatchCount);
}
break;
default:
Debug.LogErrorFormat(GLTFast.ErrorUnsupportedColorFormat, attributeType);
break;
}
}
else
{
Debug.LogErrorFormat(GLTFast.ErrorUnsupportedType, "color accessor", inputType);
}
Profiler.EndSample();
return(jobHandle);
}
