//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); }
/// <summary> /// Gets the property raw data as a Color4D. /// </summary> /// <returns>Color4D</returns> public Color4D GetColor4DValue() { if (m_type != PropertyType.Float || m_rawValue == null) { return(new Color4D()); } //We may have a Color that's RGB, so still read it and set alpha to 1.0 unsafe { fixed(byte *ptr = m_rawValue) { if (m_rawValue.Length >= MemoryHelper.SizeOf <Color4D>()) { return(MemoryHelper.Read <Color4D>(new IntPtr(ptr))); } else if (m_rawValue.Length >= MemoryHelper.SizeOf <Color3D>()) { return(new Color4D(MemoryHelper.Read <Color3D>(new IntPtr(ptr)), 1.0f)); } } } return(new Color4D()); }
/// <summary> /// Constructs a new IOStream. /// </summary> /// <param name="pathToFile">Path to file given by Assimp</param> /// <param name="fileMode">Desired file access mode</param> public IOStream(String pathToFile, FileIOMode fileMode) { m_pathToFile = pathToFile; m_fileMode = fileMode; m_writeProc = OnAiFileWriteProc; m_readProc = OnAiFileReadProc; m_tellProc = OnAiFileTellProc; m_fileSizeProc = OnAiFileSizeProc; m_seekProc = OnAiFileSeekProc; m_flushProc = OnAiFileFlushProc; AiFile file; file.WriteProc = Marshal.GetFunctionPointerForDelegate(m_writeProc); file.ReadProc = Marshal.GetFunctionPointerForDelegate(m_readProc); file.TellProc = Marshal.GetFunctionPointerForDelegate(m_tellProc); file.FileSizeProc = Marshal.GetFunctionPointerForDelegate(m_fileSizeProc); file.SeekProc = Marshal.GetFunctionPointerForDelegate(m_seekProc); file.FlushProc = Marshal.GetFunctionPointerForDelegate(m_flushProc); file.UserData = IntPtr.Zero; m_filePtr = MemoryHelper.AllocateMemory(MemoryHelper.SizeOf <AiFile>()); Marshal.StructureToPtr(file, m_filePtr, false); }
//Transforms the root node of the scene and writes it back to the native structure private unsafe bool TransformScene(IntPtr scene) { BuildMatrix(); try { if (m_scaleRot != Matrix.Identity) { AiScene aiScene = MemoryHelper.MarshalStructure <AiScene>(scene); if (aiScene.RootNode == IntPtr.Zero) { return(false); } IntPtr matrixPtr = IntPtr.Add(aiScene.RootNode, MemoryHelper.SizeOf <AiString>()); //Skip over Node Name Matrix matrix = *((Matrix *)matrixPtr); //Get the root transform matrix = matrix * m_scaleRot; //Transform //Write back to unmanaged mem *((Matrix *)matrixPtr) = matrix; return(true); } } catch (Exception) { } return(false); }
private unsafe T GetValueAs <T>() where T : struct { int size = MemoryHelper.SizeOf <T>(); if (m_rawValue != null && m_rawValue.Length >= size) { fixed(byte *ptr = m_rawValue) { return(MemoryHelper.Read <T>(new IntPtr(ptr))); } } return(default(T)); }
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); }
/// <summary> /// Constructs a new IOSystem. /// </summary> public IOSystem() { m_openProc = OnAiFileOpenProc; m_closeProc = OnAiFileCloseProc; AiFileIO fileIO; fileIO.OpenProc = Marshal.GetFunctionPointerForDelegate(m_openProc); fileIO.CloseProc = Marshal.GetFunctionPointerForDelegate(m_closeProc); fileIO.UserData = IntPtr.Zero; m_fileIOPtr = MemoryHelper.AllocateMemory(MemoryHelper.SizeOf <AiFileIO>()); Marshal.StructureToPtr(fileIO, m_fileIOPtr, false); m_openedFiles = new Dictionary <IntPtr, IOStream>(); }
private unsafe T[] GetValueArrayAs <T>(int count) where T : struct { int size = MemoryHelper.SizeOf <T>(); if (m_rawValue != null && (m_rawValue.Length >= (size * count))) { T[] array = new T[count]; fixed(byte *ptr = m_rawValue) { MemoryHelper.Read <T>(new IntPtr(ptr), array, 0, count); } return(array); } return(null); }
private void Initialize(LoggingCallback callback, String userData) { if (userData == null) { userData = String.Empty; } m_assimpCallback = OnAiLogStreamCallback; m_logCallback = callback; m_userData = userData; AiLogStream logStream; logStream.Callback = Marshal.GetFunctionPointerForDelegate(m_assimpCallback); logStream.UserData = IntPtr.Zero; m_logstreamPtr = MemoryHelper.AllocateMemory(MemoryHelper.SizeOf <AiLogStream>()); Marshal.StructureToPtr(logStream, m_logstreamPtr, false); }
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); }
/// <summary> /// Frees unmanaged memory created by <see cref="IMarshalable{Bone, AiBone}.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; } AiBone aiBone = MemoryHelper.Read <AiBone>(nativeValue); int numWeights = MemoryHelper.Read <int>(MemoryHelper.AddIntPtr(nativeValue, MemoryHelper.SizeOf <AiString>())); IntPtr weightsPtr = MemoryHelper.AddIntPtr(nativeValue, MemoryHelper.SizeOf <AiString>() + sizeof(uint)); if (aiBone.NumWeights > 0 && aiBone.Weights != IntPtr.Zero) { MemoryHelper.FreeMemory(aiBone.Weights); } if (freeNative) { MemoryHelper.FreeMemory(nativeValue); } }
/// <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); }