/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <NodeAnimationChannel, AiNodeAnim> .FromNative(ref AiNodeAnim nativeValue)
{
m_nodeName = nativeValue.NodeName.GetString();
m_preState = nativeValue.Prestate;
m_postState = nativeValue.PostState;
m_positionKeys.Clear();
m_rotationKeys.Clear();
m_scalingKeys.Clear();
if (nativeValue.NumPositionKeys > 0 && nativeValue.PositionKeys != IntPtr.Zero)
{
m_positionKeys.AddRange(MemoryHelper.FromNativeArray <VectorKey>(nativeValue.PositionKeys, (int)nativeValue.NumPositionKeys));
}
if (nativeValue.NumRotationKeys > 0 && nativeValue.RotationKeys != IntPtr.Zero)
{
m_rotationKeys.AddRange(MemoryHelper.FromNativeArray <QuaternionKey>(nativeValue.RotationKeys, (int)nativeValue.NumRotationKeys));
}
if (nativeValue.NumScalingKeys > 0 && nativeValue.ScalingKeys != IntPtr.Zero)
{
m_scalingKeys.AddRange(MemoryHelper.FromNativeArray <VectorKey>(nativeValue.ScalingKeys, (int)nativeValue.NumScalingKeys));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Node, AiNode> .FromNative(ref AiNode nativeValue)
{
m_name = nativeValue.Name.GetString();
m_transform = nativeValue.Transformation;
m_parent = null;
m_children.Clear();
m_meshes.Clear();
m_metaData.Clear();
if (nativeValue.MetaData != IntPtr.Zero)
{
Metadata data = MemoryHelper.FromNativePointer <Metadata, AiMetadata>(nativeValue.MetaData);
foreach (KeyValuePair <String, Metadata.Entry> kv in data)
{
m_metaData.Add(kv.Key, kv.Value);
}
}
if (nativeValue.NumMeshes > 0 && nativeValue.Meshes != IntPtr.Zero)
{
m_meshes.AddRange(MemoryHelper.FromNativeArray <int>(nativeValue.Meshes, (int)nativeValue.NumMeshes));
}
if (nativeValue.NumChildren > 0 && nativeValue.Children != IntPtr.Zero)
{
m_children.AddRange(MemoryHelper.FromNativeArray <Node, AiNode>(nativeValue.Children, (int)nativeValue.NumChildren, true));
}
}
/// <summary>
/// Frees unmanaged memory created by <see cref="IMarshalable{Metadata, AiMetadata}.ToNative"/>.
/// </summary>
/// <param name="nativeValue">Native value to free</param>
/// <param name="freeNative">True if the unmanaged memory should be freed, false otherwise.</param>
public static void FreeNative(IntPtr nativeValue, bool freeNative)
{
if (nativeValue == IntPtr.Zero)
{
return;
}
AiMetadata aiMetadata = MemoryHelper.MarshalStructure <AiMetadata>(nativeValue);
if (aiMetadata.keys != IntPtr.Zero)
{
MemoryHelper.FreeMemory(aiMetadata.keys);
}
if (aiMetadata.Values != IntPtr.Zero)
{
AiMetadataEntry[] entries = MemoryHelper.FromNativeArray <AiMetadataEntry>(aiMetadata.Values, (int)aiMetadata.NumProperties);
foreach (AiMetadataEntry entry in entries)
{
if (entry.Data != IntPtr.Zero)
{
MemoryHelper.FreeMemory(entry.Data);
}
}
MemoryHelper.FreeMemory(aiMetadata.Values);
}
if (freeNative)
{
MemoryHelper.FreeMemory(nativeValue);
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <EmbeddedTexture, AiTexture> .FromNative(ref AiTexture nativeValue)
{
m_isCompressed = nativeValue.Height == 0;
if (IsCompressed)
{
m_width = 0;
m_height = 0;
m_nonCompressedData = null;
m_compressedData = null;
if (nativeValue.Width > 0 && nativeValue.Data != IntPtr.Zero)
{
m_compressedData = MemoryHelper.FromNativeArray <byte>(nativeValue.Data, (int)nativeValue.Width);
}
m_compressedFormatHint = nativeValue.GetFormatHint();
}
else
{
m_compressedData = null;
m_compressedFormatHint = null;
m_nonCompressedData = null;
m_width = (int)nativeValue.Width;
m_height = (int)nativeValue.Height;
int size = m_width * m_height;
if (size > 0 && nativeValue.Data != IntPtr.Zero)
{
m_nonCompressedData = MemoryHelper.FromNativeArray <Texel>(nativeValue.Data, size);
}
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Metadata, AiMetadata> .FromNative(ref AiMetadata nativeValue)
{
Clear();
if (nativeValue.NumProperties == 0 || nativeValue.keys == IntPtr.Zero || nativeValue.Values == IntPtr.Zero)
{
return;
}
AiString[] keys = MemoryHelper.FromNativeArray <AiString>(nativeValue.keys, (int)nativeValue.NumProperties);
AiMetadataEntry[] entries = MemoryHelper.FromNativeArray <AiMetadataEntry>(nativeValue.Values, (int)nativeValue.NumProperties);
for (int i = 0; i < nativeValue.NumProperties; i++)
{
String key = keys[i].GetString();
AiMetadataEntry entry = entries[i];
if (String.IsNullOrEmpty(key) || entry.Data == IntPtr.Zero)
{
continue;
}
Object data = null;
switch (entry.DataType)
{
case MetaDataType.Bool:
data = MemoryHelper.Read <bool>(entry.Data);
break;
case MetaDataType.Float:
data = MemoryHelper.Read <float>(entry.Data);
break;
case MetaDataType.Int:
data = MemoryHelper.Read <int>(entry.Data);
break;
case MetaDataType.String:
AiString aiString = MemoryHelper.Read <AiString>(entry.Data);
data = aiString.GetString();
break;
case MetaDataType.UInt64:
data = MemoryHelper.Read <UInt64>(entry.Data);
break;
case MetaDataType.Vector3D:
data = MemoryHelper.Read <Vector3D>(entry.Data);
break;
}
if (data != null)
{
Add(key, new Entry(entry.DataType, data));
}
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Face, AiFace> .FromNative(ref AiFace nativeValue)
{
m_indices.Clear();
if (nativeValue.NumIndices > 0 && nativeValue.Indices != IntPtr.Zero)
{
m_indices.AddRange(MemoryHelper.FromNativeArray <int>(nativeValue.Indices, (int)nativeValue.NumIndices));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <MeshAnimationChannel, AiMeshAnim> .FromNative(ref AiMeshAnim nativeValue)
{
m_name = nativeValue.Name.ToString();
m_meshKeys.Clear();
if (nativeValue.NumKeys > 0 && nativeValue.Keys != IntPtr.Zero)
{
m_meshKeys.AddRange(MemoryHelper.FromNativeArray <MeshKey>(nativeValue.Keys, (int)nativeValue.NumKeys));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <MaterialProperty, AiMaterialProperty> .FromNative(ref AiMaterialProperty nativeValue)
{
m_name = nativeValue.Key.GetString();
m_type = nativeValue.Type;
m_texIndex = (int)nativeValue.Index;
m_texType = nativeValue.Semantic;
m_rawValue = null;
if (nativeValue.DataLength > 0 && nativeValue.Data != IntPtr.Zero)
m_rawValue = MemoryHelper.FromNativeArray <byte>(nativeValue.Data, (int)nativeValue.DataLength); }
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Bone, AiBone> .FromNative(ref AiBone nativeValue)
{
m_name = nativeValue.Name.GetString();
m_offsetMatrix = nativeValue.OffsetMatrix;
m_weights.Clear();
if (nativeValue.NumWeights > 0 && nativeValue.Weights != IntPtr.Zero)
{
m_weights.AddRange(MemoryHelper.FromNativeArray <VertexWeight>(nativeValue.Weights, (int)nativeValue.NumWeights));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <MeshAnimationAttachment, AiAnimMesh> .FromNative(ref AiAnimMesh nativeValue)
{
ClearBuffers();
int vertexCount = (int)nativeValue.NumVertices;
if (vertexCount > 0)
{
if (nativeValue.Vertices != IntPtr.Zero)
{
m_vertices.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Vertices, vertexCount));
}
if (nativeValue.Normals != IntPtr.Zero)
{
m_normals.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Normals, vertexCount));
}
if (nativeValue.Tangents != IntPtr.Zero)
{
m_tangents.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Tangents, vertexCount));
}
if (nativeValue.BiTangents != IntPtr.Zero)
{
m_bitangents.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.BiTangents, vertexCount));
}
//Vertex Color channels
for (int i = 0; i < nativeValue.Colors.Length; i++)
{
IntPtr colorPtr = nativeValue.Colors[i];
if (colorPtr != IntPtr.Zero)
{
m_colors[i].AddRange(MemoryHelper.FromNativeArray <Color4D>(colorPtr, vertexCount));
}
}
//Texture coordinate channels
for (int i = 0; i < nativeValue.TextureCoords.Length; i++)
{
IntPtr texCoordsPtr = nativeValue.TextureCoords[i];
if (texCoordsPtr != IntPtr.Zero)
{
m_texCoords[i].AddRange(MemoryHelper.FromNativeArray <Vector3D>(texCoordsPtr, vertexCount));
}
}
}
m_weight = nativeValue.Weight;
}
/// <summary>
/// Creates a new ExportDataBlob.
/// </summary>
/// <param name="dataBlob">Unmanaged structure.</param>
internal ExportDataBlob(ref AiExportDataBlob dataBlob)
{
m_name = dataBlob.Name.GetString();
if(dataBlob.Size.ToUInt32() > 0 && dataBlob.Data != IntPtr.Zero)
m_data = MemoryHelper.FromNativeArray<byte>(dataBlob.Data, (int) dataBlob.Size.ToUInt32());
m_next = null;
if(dataBlob.NextBlob != IntPtr.Zero)
{
AiExportDataBlob nextBlob = MemoryHelper.MarshalStructure<AiExportDataBlob>(dataBlob.NextBlob);
m_next = new ExportDataBlob(ref nextBlob);
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Scene, AiScene> .FromNative(ref AiScene nativeValue)
{
Clear();
m_flags = nativeValue.Flags;
//Read materials
if (nativeValue.NumMaterials > 0 && nativeValue.Materials != IntPtr.Zero)
{
m_materials.AddRange(MemoryHelper.FromNativeArray <Material, AiMaterial>(nativeValue.Materials, (int)nativeValue.NumMaterials, true));
}
//Read scenegraph
if (nativeValue.RootNode != IntPtr.Zero)
{
m_rootNode = MemoryHelper.FromNativePointer <Node, AiNode>(nativeValue.RootNode);
}
//Read meshes
if (nativeValue.NumMeshes > 0 && nativeValue.Meshes != IntPtr.Zero)
{
m_meshes.AddRange(MemoryHelper.FromNativeArray <Mesh, AiMesh>(nativeValue.Meshes, (int)nativeValue.NumMeshes, true));
}
//Read lights
if (nativeValue.NumLights > 0 && nativeValue.Lights != IntPtr.Zero)
{
m_lights.AddRange(MemoryHelper.FromNativeArray <Light, AiLight>(nativeValue.Lights, (int)nativeValue.NumLights, true));
}
//Read cameras
if (nativeValue.NumCameras > 0 && nativeValue.Cameras != IntPtr.Zero)
{
m_cameras.AddRange(MemoryHelper.FromNativeArray <Camera, AiCamera>(nativeValue.Cameras, (int)nativeValue.NumCameras, true));
}
//Read textures
if (nativeValue.NumTextures > 0 && nativeValue.Textures != IntPtr.Zero)
{
m_textures.AddRange(MemoryHelper.FromNativeArray <EmbeddedTexture, AiTexture>(nativeValue.Textures, (int)nativeValue.NumTextures, true));
}
//Read animations
if (nativeValue.NumAnimations > 0 && nativeValue.Animations != IntPtr.Zero)
{
m_animations.AddRange(MemoryHelper.FromNativeArray <Animation, AiAnimation>(nativeValue.Animations, (int)nativeValue.NumAnimations, true));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Node, AiNode> .FromNative(ref AiNode nativeValue)
{
m_name = nativeValue.Name.GetString();
m_transform = nativeValue.Transformation;
m_parent = null;
m_children.Clear();
m_meshes.Clear();
if (nativeValue.NumMeshes > 0 && nativeValue.Meshes != IntPtr.Zero)
{
m_meshes.AddRange(MemoryHelper.FromNativeArray <int>(nativeValue.Meshes, (int)nativeValue.NumMeshes));
}
if (nativeValue.NumChildren > 0 && nativeValue.Children != IntPtr.Zero)
{
m_children.AddRange(MemoryHelper.FromNativeArray <Node, AiNode>(nativeValue.Children, (int)nativeValue.NumChildren, true));
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Animation, AiAnimation> .FromNative(ref AiAnimation nativeValue)
{
m_nodeChannels.Clear();
m_meshChannels.Clear();
m_name = nativeValue.Name.GetString();
m_duration = nativeValue.Duration;
m_ticksPerSecond = nativeValue.TicksPerSecond;
if (nativeValue.NumChannels > 0 && nativeValue.Channels != IntPtr.Zero)
{
m_nodeChannels.AddRange(MemoryHelper.FromNativeArray <NodeAnimationChannel, AiNodeAnim>(nativeValue.Channels, (int)nativeValue.NumChannels, true));
}
if (nativeValue.NumMeshChannels > 0 && nativeValue.MeshChannels != IntPtr.Zero)
{
m_meshChannels.AddRange(MemoryHelper.FromNativeArray <MeshAnimationChannel, AiMeshAnim>(nativeValue.MeshChannels, (int)nativeValue.NumMeshChannels, true));
}
}
private static unsafe byte[] SetMaterialString(String value, byte[] existing)
{
if (String.IsNullOrEmpty(value))
{
return(null);
}
int stringSize = Encoding.UTF8.GetByteCount(value);
if (stringSize < 0)
{
return(null);
}
int size = stringSize + 1 + sizeof(int);
byte[] data = existing;
if (existing == null || existing.Length != size)
{
data = new byte[size];
fixed(byte *bytePtr = &data[0])
{
MemoryHelper.Write <int>(new IntPtr(bytePtr), ref stringSize);
byte[] utfBytes = Encoding.UTF8.GetBytes(value);
MemoryHelper.Write <byte>(new IntPtr(bytePtr + sizeof(int)), utfBytes, 0, utfBytes.Length);
//Last byte should be zero
}
return(data);
}
#region IMarshalable Implementation
/// <summary>
/// Gets if the native value type is blittable (that is, does not require marshaling by the runtime, e.g. has MarshalAs attributes).
/// </summary>
bool IMarshalable <MaterialProperty, AiMaterialProperty> .IsNativeBlittable {
get { return(true); }
}
/// <summary>
/// Writes the managed data to the native value.
/// </summary>
/// <param name="thisPtr">Optional pointer to the memory that will hold the native value.</param>
/// <param name="nativeValue">Output native value</param>
void IMarshalable <MaterialProperty, AiMaterialProperty> .ToNative(IntPtr thisPtr, out AiMaterialProperty nativeValue)
{
nativeValue.Key = new AiString(m_name);
nativeValue.Type = m_type;
nativeValue.Index = (uint)m_texIndex;
nativeValue.Semantic = m_texType;
nativeValue.Data = IntPtr.Zero;
nativeValue.DataLength = 0;
if (m_rawValue != null)
{
nativeValue.DataLength = (uint)m_rawValue.Length;
nativeValue.Data = MemoryHelper.ToNativeArray <byte>(m_rawValue);
}
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <MaterialProperty, AiMaterialProperty> .FromNative(ref AiMaterialProperty nativeValue)
{
m_name = nativeValue.Key.GetString();
m_type = nativeValue.Type;
m_texIndex = (int)nativeValue.Index;
m_texType = nativeValue.Semantic;
m_rawValue = null;
if (nativeValue.DataLength > 0 && nativeValue.Data != IntPtr.Zero)
m_rawValue = MemoryHelper.FromNativeArray <byte>(nativeValue.Data, (int)nativeValue.DataLength); }
}
/// <summary>
/// Reads the unmanaged data from the native value.
/// </summary>
/// <param name="nativeValue">Input native value</param>
void IMarshalable <Mesh, AiMesh> .FromNative(ref AiMesh nativeValue)
{
ClearBuffers();
int vertexCount = (int)nativeValue.NumVertices;
m_name = nativeValue.Name.GetString();
m_materialIndex = (int)nativeValue.MaterialIndex;
//Load Per-vertex components
if (vertexCount > 0)
{
//Positions
if (nativeValue.Vertices != IntPtr.Zero)
{
m_vertices.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Vertices, vertexCount));
}
//Normals
if (nativeValue.Normals != IntPtr.Zero)
{
m_normals.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Normals, vertexCount));
}
//Tangents
if (nativeValue.Tangents != IntPtr.Zero)
{
m_tangents.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.Tangents, vertexCount));
}
//BiTangents
if (nativeValue.BiTangents != IntPtr.Zero)
{
m_bitangents.AddRange(MemoryHelper.FromNativeArray <Vector3D>(nativeValue.BiTangents, vertexCount));
}
//Vertex Color channels
for (int i = 0; i < nativeValue.Colors.Length; i++)
{
IntPtr colorPtr = nativeValue.Colors[i];
if (colorPtr != IntPtr.Zero)
{
m_colors[i].AddRange(MemoryHelper.FromNativeArray <Color4D>(colorPtr, vertexCount));
}
}
//Texture coordinate channels
for (int i = 0; i < nativeValue.TextureCoords.Length; i++)
{
IntPtr texCoordsPtr = nativeValue.TextureCoords[i];
if (texCoordsPtr != IntPtr.Zero)
{
m_texCoords[i].AddRange(MemoryHelper.FromNativeArray <Vector3D>(texCoordsPtr, vertexCount));
}
}
//UV components for each tex coordinate channel
for (int i = 0; i < nativeValue.NumUVComponents.Length; i++)
{
m_texComponentCount[i] = (int)nativeValue.NumUVComponents[i];
}
}
//Faces
if (nativeValue.NumFaces > 0 && nativeValue.Faces != IntPtr.Zero)
{
m_faces.AddRange(MemoryHelper.FromNativeArray <Face, AiFace>(nativeValue.Faces, (int)nativeValue.NumFaces));
}
//Bones
if (nativeValue.NumBones > 0 && nativeValue.Bones != IntPtr.Zero)
{
m_bones.AddRange(MemoryHelper.FromNativeArray <Bone, AiBone>(nativeValue.Bones, (int)nativeValue.NumBones, true));
}
//Attachment meshes
if (nativeValue.NumAnimMeshes > 0 && nativeValue.AnimMeshes != IntPtr.Zero)
{
m_meshAttachments.AddRange(MemoryHelper.FromNativeArray <MeshAnimationAttachment, AiAnimMesh>(nativeValue.AnimMeshes, (int)nativeValue.NumAnimMeshes, true));
}
}