/// <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)); } }