//Transforms the root node of the scene and writes it back to the native structure
private bool TransformScene(IntPtr scene)
{
BuildMatrix();
try
{
if (!m_scaleRot.IsIdentity)
{
AiScene aiScene = MemoryHelper.MarshalStructure <AiScene>(scene);
if (aiScene.RootNode == IntPtr.Zero)
{
return(false);
}
IntPtr matrixPtr = MemoryHelper.AddIntPtr(aiScene.RootNode, MemoryHelper.SizeOf <AiString>()); //Skip over Node Name
Matrix4x4 matrix = MemoryHelper.Read <Matrix4x4>(matrixPtr); //Get the root transform
matrix = matrix * m_scaleRot; //Transform
//Write back to unmanaged mem
MemoryHelper.Write <Matrix4x4>(matrixPtr, ref matrix);
return(true);
}
}
catch (Exception)
{
}
return(false);
}
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);
}
private UIntPtr OnAiFileReadProc(IntPtr file, IntPtr dataRead, UIntPtr sizeOfElemInBytes, UIntPtr numElements)
{
if (m_filePtr != file)
{
return(UIntPtr.Zero);
}
long longSize = (long)sizeOfElemInBytes.ToUInt64();
long longNum = (long)numElements.ToUInt64();
long count = longSize * longNum;
byte[] byteBuffer = GetByteBuffer(longSize, longNum);
long actualCount = 0;
try
{
actualCount = Read(byteBuffer, count);
if (actualCount > 0)
{
MemoryHelper.Write <byte>(dataRead, byteBuffer, 0, (int)actualCount);
}
}
catch (Exception) { /*Assimp will report an IO error*/ }
return(new UIntPtr((ulong)actualCount / (ulong)longSize));
}
/// <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 <Node, AiNode> .ToNative(IntPtr thisPtr, out AiNode nativeValue)
{
nativeValue.Name = new AiString(m_name);
nativeValue.Transformation = m_transform;
nativeValue.Parent = IntPtr.Zero;
nativeValue.NumMeshes = (uint)m_meshes.Count;
nativeValue.Meshes = IntPtr.Zero;
nativeValue.MetaData = IntPtr.Zero;
//If has metadata, create it, otherwise it should be NULL
if (m_metaData.Count > 0)
{
nativeValue.MetaData = MemoryHelper.ToNativePointer <Metadata, AiMetadata>(m_metaData);
}
if (nativeValue.NumMeshes > 0)
{
nativeValue.Meshes = MemoryHelper.ToNativeArray <int>(m_meshes.ToArray());
}
//Now descend through the children
nativeValue.NumChildren = (uint)m_children.Count;
int numChildren = (int)nativeValue.NumChildren;
int stride = IntPtr.Size;
IntPtr childrenPtr = IntPtr.Zero;
if (numChildren > 0)
{
childrenPtr = MemoryHelper.AllocateMemory(numChildren * IntPtr.Size);
for (int i = 0; i < numChildren; i++)
{
IntPtr currPos = MemoryHelper.AddIntPtr(childrenPtr, stride * i);
Node child = m_children[i];
IntPtr childPtr = IntPtr.Zero;
//Recursively create the children and its children
if (child != null)
{
childPtr = ToNativeRecursive(thisPtr, child);
}
//Write the child's node ptr to our array
MemoryHelper.Write <IntPtr>(currPos, ref childPtr);
}
}
//Finally finish writing to the native struct
nativeValue.Children = childrenPtr;
}
private unsafe bool SetValueAs <T>(T value) where T : struct
{
int size = MemoryHelper.SizeOf <T>();
//Resize byte array if necessary
if (m_rawValue == null || m_rawValue.Length != size)
{
m_rawValue = new byte[size];
fixed(byte *ptr = m_rawValue)
MemoryHelper.Write <T>(new IntPtr(ptr), value);
return(true);
}
private unsafe bool SetValueArrayAs <T>(T[] data) where T : struct
{
if (data == null || data.Length == 0)
{
return(false);
}
int size = MemoryHelper.SizeOf <T>(data);
//Resize byte array if necessary
if (m_rawValue == null || m_rawValue.Length != size)
{
m_rawValue = new byte[size];
fixed(byte *ptr = m_rawValue)
MemoryHelper.Write <T>(new IntPtr(ptr), data, 0, data.Length);
return(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>
/// 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 <Metadata, AiMetadata> .ToNative(IntPtr thisPtr, out AiMetadata nativeValue)
{
nativeValue = new AiMetadata();
nativeValue.NumProperties = (uint)Count;
AiString[] keys = new AiString[Count];
AiMetadataEntry[] entries = new AiMetadataEntry[Count];
int index = 0;
foreach (KeyValuePair <String, Entry> kv in this)
{
AiMetadataEntry entry = new AiMetadataEntry();
entry.DataType = kv.Value.DataType;
switch (kv.Value.DataType)
{
case MetaDataType.Bool:
entry.Data = MemoryHelper.AllocateMemory(sizeof(bool));
bool boolValue = (bool)kv.Value.Data;
MemoryHelper.Write <bool>(entry.Data, ref boolValue);
break;
case MetaDataType.Float:
entry.Data = MemoryHelper.AllocateMemory(sizeof(float));
float floatValue = (float)kv.Value.Data;
MemoryHelper.Write <float>(entry.Data, ref floatValue);
break;
case MetaDataType.Int:
entry.Data = MemoryHelper.AllocateMemory(sizeof(int));
int intValue = (int)kv.Value.Data;
MemoryHelper.Write <int>(entry.Data, ref intValue);
break;
case MetaDataType.String:
entry.Data = MemoryHelper.AllocateMemory(MemoryHelper.SizeOf <AiString>());
AiString aiStringValue = new AiString(kv.Value.Data as String);
MemoryHelper.Write <AiString>(entry.Data, ref aiStringValue);
break;
case MetaDataType.UInt64:
entry.Data = MemoryHelper.AllocateMemory(sizeof(UInt64));
UInt64 uint64Value = (UInt64)kv.Value.Data;
MemoryHelper.Write <UInt64>(entry.Data, ref uint64Value);
break;
case MetaDataType.Vector3D:
entry.Data = MemoryHelper.AllocateMemory(MemoryHelper.SizeOf <Vector3D>());
Vector3D vectorValue = (Vector3D)kv.Value.Data;
MemoryHelper.Write <Vector3D>(entry.Data, ref vectorValue);
break;
}
keys[index] = new AiString(kv.Key);
entries[index] = entry;
index++;
}
nativeValue.keys = MemoryHelper.ToNativeArray <AiString>(keys);
nativeValue.Values = MemoryHelper.ToNativeArray <AiMetadataEntry>(entries);
}
private IntPtr ToNativeRecursive(IntPtr parentPtr, Node node)
{
if (node == null)
{
return(IntPtr.Zero);
}
int sizeofNative = MemoryHelper.SizeOf <AiNode>();
//Allocate the memory that will hold the node
IntPtr nodePtr = MemoryHelper.AllocateMemory(sizeofNative);
//First fill the native struct
AiNode nativeValue;
nativeValue.Name = new AiString(node.m_name);
nativeValue.Transformation = node.m_transform;
nativeValue.Parent = parentPtr;
nativeValue.NumMeshes = (uint)node.m_meshes.Count;
nativeValue.Meshes = MemoryHelper.ToNativeArray <int>(node.m_meshes.ToArray());
nativeValue.MetaData = IntPtr.Zero;
//If has metadata, create it, otherwise it should be NULL
if (m_metaData.Count > 0)
{
nativeValue.MetaData = MemoryHelper.ToNativePointer <Metadata, AiMetadata>(m_metaData);
}
//Now descend through the children
nativeValue.NumChildren = (uint)node.m_children.Count;
int numChildren = (int)nativeValue.NumChildren;
int stride = IntPtr.Size;
IntPtr childrenPtr = IntPtr.Zero;
if (numChildren > 0)
{
childrenPtr = MemoryHelper.AllocateMemory(numChildren * IntPtr.Size);
for (int i = 0; i < numChildren; i++)
{
IntPtr currPos = MemoryHelper.AddIntPtr(childrenPtr, stride * i);
Node child = node.m_children[i];
IntPtr childPtr = IntPtr.Zero;
//Recursively create the children and its children
if (child != null)
{
childPtr = ToNativeRecursive(nodePtr, child);
}
//Write the child's node ptr to our array
MemoryHelper.Write <IntPtr>(currPos, ref childPtr);
}
}
//Finall finish writing to the native struct, and write the whole thing to the memory we allocated previously
nativeValue.Children = childrenPtr;
MemoryHelper.Write <AiNode>(nodePtr, ref nativeValue);
return(nodePtr);
}