RenderModel LoadRenderModel(CVRRenderModels renderModels, string renderModelName, string baseName) { var pRenderModel = System.IntPtr.Zero; EVRRenderModelError error; while (true) { error = renderModels.LoadRenderModel_Async(renderModelName, ref pRenderModel); if (error != EVRRenderModelError.Loading) { break; } #if UNITY_STANDALONE System.Threading.Thread.Sleep(1); #endif } if (error != EVRRenderModelError.None) { Debug.LogError(string.Format("Failed to load render model {0} - {1}", renderModelName, error.ToString())); return(null); } var renderModel = MarshalRenderModel(pRenderModel); var vertices = new Vector3[renderModel.unVertexCount]; var normals = new Vector3[renderModel.unVertexCount]; var uv = new Vector2[renderModel.unVertexCount]; var type = typeof(RenderModel_Vertex_t); for (int iVert = 0; iVert < renderModel.unVertexCount; iVert++) { var ptr = new System.IntPtr(renderModel.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type)); var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type); vertices[iVert] = new Vector3(vert.vPosition.v0, vert.vPosition.v1, -vert.vPosition.v2); normals[iVert] = new Vector3(vert.vNormal.v0, vert.vNormal.v1, -vert.vNormal.v2); uv[iVert] = new Vector2(vert.rfTextureCoord0, vert.rfTextureCoord1); } int indexCount = (int)renderModel.unTriangleCount * 3; var indices = new short[indexCount]; Marshal.Copy(renderModel.rIndexData, indices, 0, indices.Length); var triangles = new int[indexCount]; for (int iTri = 0; iTri < renderModel.unTriangleCount; iTri++) { triangles[iTri * 3 + 0] = (int)indices[iTri * 3 + 2]; triangles[iTri * 3 + 1] = (int)indices[iTri * 3 + 1]; triangles[iTri * 3 + 2] = (int)indices[iTri * 3 + 0]; } var mesh = new Mesh(); mesh.vertices = vertices; mesh.normals = normals; mesh.uv = uv; mesh.triangles = triangles; #if (UNITY_5_4 || UNITY_5_3 || UNITY_5_2 || UNITY_5_1 || UNITY_5_0) mesh.Optimize(); #endif //mesh.hideFlags = HideFlags.DontUnloadUnusedAsset; // Check cache before loading texture. var material = materials[renderModel.diffuseTextureId] as Material; if (material == null || material.mainTexture == null) { var pDiffuseTexture = System.IntPtr.Zero; while (true) { error = renderModels.LoadTexture_Async(renderModel.diffuseTextureId, ref pDiffuseTexture); if (error != EVRRenderModelError.Loading) { break; } #if UNITY_STANDALONE System.Threading.Thread.Sleep(1); #endif } if (error == EVRRenderModelError.None) { var diffuseTexture = MarshalRenderModel_TextureMap(pDiffuseTexture); var texture = new Texture2D(diffuseTexture.unWidth, diffuseTexture.unHeight, TextureFormat.ARGB32, false); if (SystemInfo.graphicsDeviceType == UnityEngine.Rendering.GraphicsDeviceType.Direct3D11) { texture.Apply(); while (true) { error = renderModels.LoadIntoTextureD3D11_Async(renderModel.diffuseTextureId, texture.GetNativeTexturePtr()); if (error != EVRRenderModelError.Loading) { break; } #if UNITY_STANDALONE System.Threading.Thread.Sleep(1); #endif } } else { var textureMapData = new byte[diffuseTexture.unWidth * diffuseTexture.unHeight * 4]; // RGBA Marshal.Copy(diffuseTexture.rubTextureMapData, textureMapData, 0, textureMapData.Length); var colors = new Color32[diffuseTexture.unWidth * diffuseTexture.unHeight]; int iColor = 0; for (int iHeight = 0; iHeight < diffuseTexture.unHeight; iHeight++) { for (int iWidth = 0; iWidth < diffuseTexture.unWidth; iWidth++) { var r = textureMapData[iColor++]; var g = textureMapData[iColor++]; var b = textureMapData[iColor++]; var a = textureMapData[iColor++]; colors[iHeight * diffuseTexture.unWidth + iWidth] = new Color32(r, g, b, a); } } texture.SetPixels32(colors); texture.Apply(); } material = new Material(shader != null ? shader : Shader.Find("Standard")); material.mainTexture = texture; //material.hideFlags = HideFlags.DontUnloadUnusedAsset; materials[renderModel.diffuseTextureId] = material; renderModels.FreeTexture(pDiffuseTexture); } else { Debug.Log("Failed to load render model texture for render model " + renderModelName); } } // Delay freeing when we can since we'll often get multiple requests for the same model right // after another (e.g. two controllers or two basestations). #if UNITY_EDITOR if (!Application.isPlaying) { renderModels.FreeRenderModel(pRenderModel); } else #endif StartCoroutine(FreeRenderModel(pRenderModel)); return(new RenderModel(mesh, material)); }
public void CopyTo_NullSource_ThrowsArgumentNullException() { AssertExtensions.Throws <ArgumentNullException>("source", () => Marshal.Copy((short[])null, 0, new IntPtr(1), 0)); AssertExtensions.Throws <ArgumentNullException>("source", () => Marshal.Copy(IntPtr.Zero, new short[10], 0, 0)); }
private byte[] DecryptBlob(byte[] dwData) { if (hKey == null && hAlg == null) { return(ProtectedData.Unprotect(dwData, null, DataProtectionScope.CurrentUser)); } byte[] dwDataOut = null; // magic decryption happens here BCrypt.BCRYPT_AUTHENTICATED_CIPHER_MODE_INFO info; int dwDataOutLen; //IntPtr pDataOut = IntPtr.Zero; IntPtr pData = IntPtr.Zero; uint ntStatus; byte[] subArrayNoV10; int pcbResult = 0; unsafe { if (ByteArrayEquals(dwData, 0, DPAPI_CHROME_UNKV10, 0, 3)) { subArrayNoV10 = new byte[dwData.Length - DPAPI_CHROME_UNKV10.Length]; Array.Copy(dwData, 3, subArrayNoV10, 0, dwData.Length - DPAPI_CHROME_UNKV10.Length); pData = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * dwData.Length); //byte[] shiftedEncVal = new byte[dwData.Length - 3]; //Array.Copy(dwData, 3, shiftedEncVal, 0, dwData.Length - 3); //IntPtr shiftedEncValPtr = IntPtr.Zero; try { //shiftedEncValPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * shiftedEncVal.Length); Marshal.Copy(dwData, 0, pData, dwData.Length); Utils.MiscUtils.BCRYPT_INIT_AUTH_MODE_INFO(out info); info.pbNonce = (byte *)(pData + DPAPI_CHROME_UNKV10.Length); info.cbNonce = 12; info.pbTag = info.pbNonce + dwData.Length - (DPAPI_CHROME_UNKV10.Length + AES_BLOCK_SIZE); // AES_BLOCK_SIZE = 16 info.cbTag = AES_BLOCK_SIZE; // AES_BLOCK_SIZE = 16 dwDataOutLen = dwData.Length - DPAPI_CHROME_UNKV10.Length - info.cbNonce - info.cbTag; dwDataOut = new byte[dwDataOutLen]; fixed(byte *pDataOut = dwDataOut) { ntStatus = BCrypt.BCryptDecrypt(hKey, info.pbNonce + info.cbNonce, dwDataOutLen, (void *)&info, null, 0, pDataOut, dwDataOutLen, out pcbResult, 0); } if (NT_SUCCESS(ntStatus)) { //Console.WriteLine("{0} : {1}", dwDataOutLen, pDataOut); } } catch (Exception ex) { } finally { if (pData != null && pData != IntPtr.Zero) { Marshal.FreeHGlobal(pData); } //if (pDataOut != null && pDataOut != IntPtr.Zero) // Marshal.FreeHGlobal(pDataOut); //if (pInfo != null && pInfo != IntPtr.Zero) // Marshal.FreeHGlobal(pDataOut); } } } return(dwDataOut); }
static public void Fill(Bitmap bmp, Point pt, Color pointColor, Color replaceColor) { BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); int[] bits = new int[data.Stride / 4 * data.Height]; Marshal.Copy(data.Scan0, bits, 0, bits.Length); int x = pt.X, y = pt.Y; Stack <Point> check = new Stack <Point>(); int To = replaceColor.ToArgb(); int From = bits[x + y * data.Stride / 4]; bits[x + y * data.Stride / 4] = To; if (To != From) { Bitmap tempBmp = new Bitmap(bmp.Width, bmp.Height); BitmapData tempdata = tempBmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); int[] tempbits = new int[tempdata.Stride / 4 * tempdata.Height]; Marshal.Copy(tempdata.Scan0, tempbits, 0, tempbits.Length); check.Push(new Point(x, y)); while (check.Count > 0) { Point cur = check.Pop(); Point next = new Point(cur.X, cur.Y - 1); foreach (Point off in new Point[] { new Point(0, -1), new Point(0, 1), new Point(-1, 0), new Point(1, 0) }) { next = new Point(cur.X + off.X, cur.Y + off.Y); if (next.X >= 0 && next.Y >= 0 && next.X < data.Width && next.Y < data.Height) { if (bits[next.X + next.Y * data.Stride / 4] == From) { check.Push(next); } bits[next.X + next.Y * data.Stride / 4] = To; tempbits[next.X + next.Y * data.Stride / 4] = To; } } } Marshal.Copy(tempbits, 0, tempdata.Scan0, tempbits.Length); bmp.UnlockBits(data); tempBmp.UnlockBits(tempdata); Graphics gra = Graphics.FromImage(bmp); gra.SmoothingMode = SmoothingMode.AntiAlias; gra.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver; gra.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; gra.DrawImage(tempBmp, 0, 0, bmp.Width, bmp.Height); } else { Bitmap tempbmp = new Bitmap(bmp.Width, bmp.Height); BitmapData tempdata = tempbmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); int[] tempbits = new int[tempdata.Stride / 4 * tempdata.Height]; Marshal.Copy(tempdata.Scan0, tempbits, 0, tempbits.Length); check.Push(new Point(x, y)); while (check.Count > 0) { Point cur = check.Pop(); Point next = new Point(cur.X, cur.Y - 1); foreach (Point off in new Point[] { new Point(0, -1), new Point(0, 1), new Point(-1, 0), new Point(1, 0) }) { next = new Point(cur.X + off.X, cur.Y + off.Y); if (next.X >= 0 && next.Y >= 0 && next.X < data.Width && next.Y < data.Height) { if (bits[next.X + next.Y * data.Stride / 4] == From) { check.Push(next); bits[next.X + next.Y * data.Stride / 4] = Color.Transparent.ToArgb(); tempbits[next.X + next.Y * data.Stride / 4] = To; } } } } Marshal.Copy(tempbits, 0, tempdata.Scan0, tempbits.Length); bmp.UnlockBits(data); tempbmp.UnlockBits(tempdata); Graphics gra = Graphics.FromImage(bmp); gra.SmoothingMode = SmoothingMode.AntiAlias; gra.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceOver; gra.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; gra.DrawImage(tempbmp, 0, 0, bmp.Width, bmp.Height); } }
private void TimerOnElapsed(object sender, EventArgs eventArgs) { IntPtr pData = IntPtr.Zero; //read in CHRocodile data while (true) { var res = TCHRDLLFunctionWrapper.GetNextSample(_deviceHandle, ref pData, out var sigNumber); if (res > 0) { //display data Marshal.Copy(pData, _oneSampleData, 0, sigNumber); if (sigNumber > 0) { for (int i = 0; i < sigNumber; i++) { _sampleBuffers[i][_currentDataPos] = _oneSampleData[i]; } _currentDataPos++; if (_currentDataPos >= _dataLength) { _currentDataPos = 0; } } } else { if (res < 0) { TCHRDLLFunctionWrapper.FlushInputBuffer(_deviceHandle); } break; } } // Convert to dictionary var curvesDict = new Dictionary <string, double[]>(); for (int i = 0; i < _signalNames.Length; i++) { curvesDict[_signalNames[i]] = _sampleBuffers[i]; } OnCurvesUpdated(curvesDict); //download spectrum int SpecType = TCHRDLLFunctionWrapper.Raw_Spectrum; if (TCHRDLLFunctionWrapper.DownloadDeviceSpectrum(_deviceHandle, SpecType, ref pData, out var signalCount) == 0) { if (signalCount > _dataLength) { signalCount = _dataLength; } Marshal.Copy(pData, _specData, 0, signalCount); // Assign 0s to unassigned entries for (int i = signalCount; i < _dataLength; i++) { _specData[i] = 0; } OnSpectrumDataUpdated(_specData); } }
public static int[] ToIntsArray(this IntPtr ptr, int size) { int[] result = new int[size]; Marshal.Copy(ptr, result, 0, size); return(result); }
/// <summary> /// Execute a second pass through the brush /// </summary> /// <param name="sourceData">The source brush, locked into memory</param> /// <param name="output">The output brush</param> /// <param name="x">The x in pixels of the image</param> /// <param name="height">The height in pixels of the image</param> /// <param name="bounds">The bounding rectangle</param> /// <param name="stride"></param> protected virtual void SecondPass(byte[] sourceData, Bitmap output, int width, int height, Rectangle bounds, int stride) { BitmapData outputLock = null; try { // Lock the output brush into memory outputLock = output.LockBits(bounds, ImageLockMode.WriteOnly, PixelFormat.Format8bppIndexed); byte[] outputData = new byte[outputLock.Stride * output.Height]; // Define the source data pointers. The source row is a byte to // keep addition of the stride value easier (as this is in bytes) //IntPtr pSourceRow = sourceData.Scan0; //IntPtr pSourcePixel = pSourceRow; //IntPtr pPreviousPixel = pSourcePixel; int srcRow = 0; int srcPixel = 0; int srcPrevPixel = 0; // Now define the destination data pointers //IntPtr pDestinationRow = outputLock.Scan0; //IntPtr pDestinationPixel = pDestinationRow; int dstRow = 0; int dstPixel = 0; // And convert the first pixel, so that I have values going into the loop byte pixelValue = QuantizePixel(new Color32(sourceData, srcPixel)); // Assign the value of the first pixel //Marshal.WriteByte(pDestinationPixel, pixelValue); outputData[dstPixel] = pixelValue; // Loop through each row for (int row = 0; row < height; row++) { // Set the source pixel to the first pixel in this row //pSourcePixel = pSourceRow; srcPixel = srcRow; // And set the destination pixel pointer to the first pixel in the row //pDestinationPixel = pDestinationRow; dstPixel = dstRow; // Loop through each pixel on this scan line for (int col = 0; col < width; col++) { // Check if this is the same as the last pixel. If so use that value // rather than calculating it again. This is an inexpensive optimisation. //if (Marshal.ReadByte(pPreviousPixel) != Marshal.ReadByte(pSourcePixel)) //{ // Quantize the pixel pixelValue = QuantizePixel(new Color32(sourceData, srcPixel)); // And setup the previous pointer //pPreviousPixel = pSourcePixel; srcPrevPixel = srcPixel; //} // And set the pixel in the output //Marshal.WriteByte(pDestinationPixel, pixelValue); outputData[dstPixel] = pixelValue; //pSourcePixel = (IntPtr)((long)pSourcePixel + _pixelSize); srcPixel += _pixelSize; //pDestinationPixel = (IntPtr)((long)pDestinationPixel + 1); dstPixel++; } // Add the stride to the source row //pSourceRow = (IntPtr)((long)pSourceRow + sourceData.Stride); srcRow += stride; // And to the destination row //pDestinationRow = (IntPtr)((long)pDestinationRow + outputLock.Stride); dstRow += outputLock.Stride; } Marshal.Copy(outputData, 0, outputLock.Scan0, outputData.Length); } finally { // Ensure that I unlock the output bits output.UnlockBits(outputLock); } }
public FileIndex(string idxFile, string mulFile, string uopFile, int length, int file, string uopEntryExtension, int idxLength, bool hasExtra) { Index = new Entry3D[length]; string idxPath = null; MulPath = null; string uopPath = null; if (Files.MulPath == null) { Files.LoadMulPath(); } if (Files.MulPath.Count > 0) { idxPath = Files.MulPath[idxFile.ToLower()]; MulPath = Files.MulPath[mulFile.ToLower()]; if (!String.IsNullOrEmpty(uopFile) && Files.MulPath.ContainsKey(uopFile.ToLower())) { uopPath = Files.MulPath[uopFile.ToLower()]; } if (String.IsNullOrEmpty(idxPath)) { idxPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(idxPath))) { idxPath = Path.Combine(Files.RootDir, idxPath); } if (!File.Exists(idxPath)) { idxPath = null; } } if (String.IsNullOrEmpty(MulPath)) { MulPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(MulPath))) { MulPath = Path.Combine(Files.RootDir, MulPath); } if (!File.Exists(MulPath)) { MulPath = null; } } if (String.IsNullOrEmpty(uopPath)) { uopPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(uopPath))) { uopPath = Path.Combine(Files.RootDir, uopPath); } if (!File.Exists(uopPath)) { uopPath = null; } else { MulPath = uopPath; } } } /* UOP files support code, written by Wyatt (c) www.ruosi.org * idxLength variable was added for compatibility with legacy code for art (see art.cs) * At the moment the only UOP file having entries with extra field is gumpartlegacy.uop, * and it's two dwords in the beginning of the entry. * It's possible that UOP can include some entries with unknown hash: not really unknown for me, but * not useful for reading legacy entries. That's why i removed unknown hash exception throwing from this code */ if (MulPath != null && MulPath.EndsWith(".uop")) { using (FileStream index = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read); FileInfo fi = new FileInfo(MulPath); string uopPattern = fi.Name.Replace(fi.Extension, "").ToLowerInvariant(); using (BinaryReader br = new BinaryReader(Stream)) { br.BaseStream.Seek(0, SeekOrigin.Begin); if (br.ReadInt32() != 0x50594D) { throw new ArgumentException("Bad UOP file."); } br.ReadInt64(); // version + signature long nextBlock = br.ReadInt64(); br.ReadInt32(); // block capacity int count = br.ReadInt32(); if (idxLength > 0) { IdxLength = idxLength * 12; } Dictionary <ulong, int> hashes = new Dictionary <ulong, int>(); for (int i = 0; i < length; i++) { string entryName = string.Format("build/{0}/{1:D8}{2}", uopPattern, i, uopEntryExtension); ulong hash = HashFileName(entryName); if (!hashes.ContainsKey(hash)) { hashes.Add(hash, i); } } br.BaseStream.Seek(nextBlock, SeekOrigin.Begin); do { int filesCount = br.ReadInt32(); nextBlock = br.ReadInt64(); for (int i = 0; i < filesCount; i++) { long offset = br.ReadInt64(); int headerLength = br.ReadInt32(); int compressedLength = br.ReadInt32(); int decompressedLength = br.ReadInt32(); ulong hash = br.ReadUInt64(); br.ReadUInt32(); // Adler32 short flag = br.ReadInt16(); int entryLength = flag == 1 ? compressedLength : decompressedLength; if (offset == 0) { continue; } int idx; if (hashes.TryGetValue(hash, out idx)) { if (idx < 0 || idx > Index.Length) { throw new IndexOutOfRangeException( "hashes dictionary and files collection have different count of entries!"); } Index[idx].lookup = (int)(offset + headerLength); Index[idx].length = entryLength; if (hasExtra) { long curPos = br.BaseStream.Position; br.BaseStream.Seek(offset + headerLength, SeekOrigin.Begin); byte[] extra = br.ReadBytes(8); short extra1 = (short)((extra[3] << 24) | (extra[2] << 16) | (extra[1] << 8) | extra[0]); short extra2 = (short)((extra[7] << 24) | (extra[6] << 16) | (extra[5] << 8) | extra[4]); Index[idx].lookup += 8; Index[idx].extra = extra1 << 16 | extra2; br.BaseStream.Seek(curPos, SeekOrigin.Begin); } } } } while (br.BaseStream.Seek(nextBlock, SeekOrigin.Begin) != 0); } } } else if ((idxPath != null) && (MulPath != null)) { using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read); int count = (int)(index.Length / 12); IdxLength = index.Length; GCHandle gc = GCHandle.Alloc(Index, GCHandleType.Pinned); byte[] buffer = new byte[index.Length]; index.Read(buffer, 0, (int)index.Length); Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int)Math.Min(IdxLength, length * 12)); gc.Free(); for (int i = count; i < length; ++i) { Index[i].lookup = -1; Index[i].length = -1; Index[i].extra = -1; } } } else { Stream = null; return; } Entry5D[] patches = Verdata.Patches; if (file > -1) { for (int i = 0; i < patches.Length; ++i) { Entry5D patch = patches[i]; if (patch.file == file && patch.index >= 0 && patch.index < length) { Index[patch.index].lookup = patch.lookup; Index[patch.index].length = patch.length | (1 << 31); Index[patch.index].extra = patch.extra; } } } }
public FileIndex(string idxFile, string mulFile, int file) { string idxPath = null; MulPath = null; if (Files.MulPath == null) { Files.LoadMulPath(); } if (Files.MulPath.Count > 0) { idxPath = Files.MulPath[idxFile.ToLower()]; MulPath = Files.MulPath[mulFile.ToLower()]; if (String.IsNullOrEmpty(idxPath)) { idxPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(idxPath))) { idxPath = Path.Combine(Files.RootDir, idxPath); } if (!File.Exists(idxPath)) { idxPath = null; } } if (String.IsNullOrEmpty(MulPath)) { MulPath = null; } else { if (String.IsNullOrEmpty(Path.GetDirectoryName(MulPath))) { MulPath = Path.Combine(Files.RootDir, MulPath); } if (!File.Exists(MulPath)) { MulPath = null; } } } if ((idxPath != null) && (MulPath != null)) { using (FileStream index = new FileStream(idxPath, FileMode.Open, FileAccess.Read, FileShare.Read)) { Stream = new FileStream(MulPath, FileMode.Open, FileAccess.Read, FileShare.Read); int count = (int)(index.Length / 12); IdxLength = index.Length; Index = new Entry3D[count]; GCHandle gc = GCHandle.Alloc(Index, GCHandleType.Pinned); byte[] buffer = new byte[index.Length]; index.Read(buffer, 0, (int)index.Length); Marshal.Copy(buffer, 0, gc.AddrOfPinnedObject(), (int)index.Length); gc.Free(); } } else { Stream = null; Index = new Entry3D[1]; return; } Entry5D[] patches = Verdata.Patches; if (file > -1) { for (int i = 0; i < patches.Length; ++i) { Entry5D patch = patches[i]; if (patch.file == file && patch.index >= 0 && patch.index < Index.Length) { Index[patch.index].lookup = patch.lookup; Index[patch.index].length = patch.length | (1 << 31); Index[patch.index].extra = patch.extra; } } } }
public void ExecuteModuleUnManaged(bool blockdlls) { string output = ""; IntPtr hReadPipe = IntPtr.Zero; IntPtr hWritePipe = IntPtr.Zero; if (!Spawner.CreatePipe(ref hReadPipe, ref hWritePipe)) { return; } Core.Natives.PROCESS_INFORMATION procInfo = new Core.Natives.PROCESS_INFORMATION(); if (blockdlls) { if (!Spawner.CreateProcess(hReadPipe, hWritePipe, this.processname, true, ref procInfo)) { return; } } else { if (!Spawner.CreateProcessPCMPBNMBSAO(hReadPipe, hWritePipe, this.processname, true, ref procInfo)) { return; } } string pipename = GetPipeName(procInfo.dwProcessId); InjectionLoaderListener injectionLoaderListener = new InjectionLoaderListener(pipename, task); byte[] payload = Core.Utility.DecompressDLL(Convert.FromBase64String(task.ModuleTask.Assembly)); //Round payload size to page size uint size = InjectionHelper.GetSectionSize(payload.Length); //Crteate section in current process IntPtr section = IntPtr.Zero; section = InjectionHelper.CreateSection(size, Core.Natives.PAGE_EXECUTE_READWRITE); if (section == IntPtr.Zero) { return; } //Map section to current process IntPtr baseAddr = IntPtr.Zero; IntPtr viewSize = (IntPtr)size; InjectionHelper.MapViewOfSection(section, Core.Natives.GetCurrentProcess(), ref baseAddr, ref viewSize, Core.Natives.PAGE_READWRITE); if (baseAddr == IntPtr.Zero) { return; } //Copy payload to current process section Marshal.Copy(payload, 0, baseAddr, payload.Length); //Map remote section IntPtr baseAddrEx = IntPtr.Zero; IntPtr viewSizeEx = (IntPtr)size; InjectionHelper.MapViewOfSection(section, procInfo.hProcess, ref baseAddrEx, ref viewSizeEx, Core.Natives.PAGE_EXECUTE); if (baseAddrEx == IntPtr.Zero || viewSizeEx == IntPtr.Zero) { return; } if (!InjectionHelper.UnMapViewOfSection(baseAddr)) { return; } // Assign address of shellcode to the target thread apc queue if (!InjectionHelper.QueueApcThread(baseAddrEx, procInfo)) { return; } InjectionHelper.SetInformationThread(procInfo); InjectionHelper.ResumeThread(procInfo); output = injectionLoaderListener.Execute(procInfo.hProcess, hReadPipe); Core.Natives.CloseHandle(procInfo.hThread); Core.Natives.CloseHandle(procInfo.hProcess); SendResponse(output); }
public static ResultStatus ImportStreamableTextureImage(ContentManager assetManager, TextureTool textureTool, TexImage texImage, TextureHelper.ImportParameters convertParameters, CancellationToken cancellationToken, ICommandContext commandContext) { // Perform normal texture importing (but don't save it to file now) var importResult = TextureHelper.ImportTextureImageRaw(textureTool, texImage, convertParameters, cancellationToken, commandContext.Logger); if (importResult != ResultStatus.Successful) { return(importResult); } // Make sure we don't compress mips data var dataUrl = convertParameters.OutputUrl + "_Data"; commandContext.AddTag(new ObjectUrl(UrlType.Content, dataUrl), Builder.DoNotCompressTag); using (var outputImage = textureTool.ConvertToStrideImage(texImage)) { if (cancellationToken.IsCancellationRequested) { return(ResultStatus.Cancelled); } // Create texture mips data containers (storage all array slices for every mip in separate chunks) var desc = outputImage.Description; List <byte[]> mipsData = new List <byte[]>(desc.MipLevels); for (int mipIndex = 0; mipIndex < desc.MipLevels; mipIndex++) { int totalSize = 0; for (int arrayIndex = 0; arrayIndex < desc.ArraySize; arrayIndex++) { var pixelBuffer = outputImage.GetPixelBuffer(arrayIndex, 0, mipIndex); totalSize += pixelBuffer.BufferStride; } var buf = new byte[totalSize]; int startIndex = 0; for (int arrayIndex = 0; arrayIndex < desc.ArraySize; arrayIndex++) { var pixelBuffer = outputImage.GetPixelBuffer(arrayIndex, 0, mipIndex); int size = pixelBuffer.BufferStride; Marshal.Copy(pixelBuffer.DataPointer, buf, startIndex, size); startIndex += size; } mipsData.Add(buf); } // Pack mip maps to the storage container ContentStorageHeader storageHeader; ContentStorage.Create(assetManager, dataUrl, mipsData, out storageHeader); if (cancellationToken.IsCancellationRequested) { return(ResultStatus.Cancelled); } // Serialize texture to file var outputTexture = new TextureSerializationData(outputImage, true, storageHeader); assetManager.Save(convertParameters.OutputUrl, outputTexture.ToSerializableVersion(), typeof(Texture)); commandContext.Logger.Verbose($"Compression successful [{dataUrl}] to ({outputImage.Description.Width}x{outputImage.Description.Height},{outputImage.Description.Format})"); } return(ResultStatus.Successful); }
private void SaveTransposedData(IChannel ch, Stream stream, ITransposeDataView data, int[] cols) { _host.AssertValue(ch); ch.AssertValue(stream); ch.AssertValue(data); ch.AssertNonEmpty(cols); ch.Assert(stream.CanSeek); // Initialize what we can in the header, though we will not be writing out things in the // header until we have confidence that things were written out correctly. TransposeLoader.Header header = default(TransposeLoader.Header); header.Signature = TransposeLoader.Header.SignatureValue; header.Version = TransposeLoader.Header.WriterVersion; header.CompatibleVersion = TransposeLoader.Header.WriterVersion; var slotType = data.GetSlotType(cols[0]); ch.AssertValue(slotType); header.RowCount = slotType.Size; header.ColumnCount = cols.Length; // We keep track of the offsets of the start of each sub-IDV, for use in writing out the // offsets/length table later. List <long> offsets = new List <long>(); // First write a bunch of zeros at the head, as a placeholder for the header that // will go there assuming we can successfully load it. We'll keep this array around // for the real marshalling and writing of the header bytes structure. byte[] headerBytes = new byte[TransposeLoader.Header.HeaderSize]; stream.Write(headerBytes, 0, headerBytes.Length); offsets.Add(stream.Position); // This is a convenient delegate to write out an IDV substream, then save the offsets // where writing stopped to the offsets list. Action <string, IDataView> viewAction = (name, view) => { using (var substream = new SubsetStream(stream)) { _internalSaver.SaveData(substream, view, Utils.GetIdentityPermutation(view.Schema.Count)); substream.Seek(0, SeekOrigin.End); ch.Info("Wrote {0} data view in {1} bytes", name, substream.Length); } offsets.Add(stream.Position); }; // First write out the no-row data, limited to these columns. IDataView subdata = new ChooseColumnsByIndexTransform(_host, new ChooseColumnsByIndexTransform.Arguments() { Indices = cols }, data); // If we want the "dual mode" row-wise and slot-wise file, don't filter out anything. if (!_writeRowData) { subdata = SkipTakeFilter.Create(_host, new SkipTakeFilter.TakeArguments() { Count = 0 }, subdata); } string msg = _writeRowData ? "row-wise data, schema, and metadata" : "schema and metadata"; viewAction(msg, subdata); foreach (var col in cols) { viewAction(data.Schema[col].Name, new TransposerUtils.SlotDataView(_host, data, col)); } // Wrote out the dataview. Write out the table offset. using (var writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen: true)) { // Format of the table is offset, length, both as 8-byte integers. // As it happens we wrote things out as adjacent sub-IDVs, so the // length can be derived from the offsets. The first will be the // start of the first sub-IDV, and all subsequent entries will be // the start/end of the current/next sub-IDV, respectively, so a total // of cols.Length + 2 entries. ch.Assert(offsets.Count == cols.Length + 2); ch.Assert(offsets[offsets.Count - 1] == stream.Position); header.SubIdvTableOffset = stream.Position; for (int c = 1; c < offsets.Count; ++c) { // 8-byte int for offsets, 8-byte int for length. writer.Write(offsets[c - 1]); writer.Write(offsets[c] - offsets[c - 1]); } header.TailOffset = stream.Position; writer.Write(TransposeLoader.Header.TailSignatureValue); // Now we are confident that things will work, so write it out. unsafe { Marshal.Copy(new IntPtr(&header), headerBytes, 0, Marshal.SizeOf(typeof(Header))); } writer.Seek(0, SeekOrigin.Begin); writer.Write(headerBytes); } }
private Bitmap SmartDownscale(Bitmap pixel, int factor, Color skip) { //generate output var output = new Bitmap(pixel.Width / factor, pixel.Height / factor); var olock = output.LockBits(new Rectangle(0, 0, output.Width, output.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb); var odat = new byte[olock.Stride * olock.Height]; //lock input for read var plock = pixel.LockBits(new Rectangle(0, 0, pixel.Width, pixel.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); var pdat = new byte[plock.Stride * plock.Height]; Marshal.Copy(plock.Scan0, pdat, 0, pdat.Length); bool useSkip = skip != Color.FromArgb(0, 0, 0, 0); int index = 0; for (int y = 0; y < output.Height; y++) { for (int x = 0; x < output.Width; x++) { //we want to sum a factor*factor area of the source and compute an average //instances of the "skip" color are ignored. int sumr = 0, sumg = 0, sumb = 0; int div = 0; for (int ix = 0; ix < factor; ix++) { for (int iy = 0; iy < factor; iy++) { var srcIndex = ((x * factor + ix) + (y * factor + iy) * pixel.Width) * 4; if (!(useSkip && pdat[srcIndex] == skip.B && pdat[srcIndex + 1] == skip.G && pdat[srcIndex + 2] == skip.R)) { div++; sumr += pdat[srcIndex + 2]; sumg += pdat[srcIndex + 1]; sumb += pdat[srcIndex]; } } } if (div == 0) { div = 1; sumr = skip.R; sumg = skip.G; sumb = skip.B; } else { } odat[index] = (byte)(sumb / div); odat[index + 1] = (byte)(sumg / div); odat[index + 2] = (byte)(sumr / div); odat[index + 3] = 255; index += 4; } } pixel.UnlockBits(plock); Marshal.Copy(odat, 0, olock.Scan0, odat.Length); output.UnlockBits(olock); return(output); }
private void ReplaceSprite(Bitmap[] bmps, int frame) { var pixel = bmps[0]; //first search pixel for the bounding rectangle. var plock = pixel.LockBits(new Rectangle(0, 0, pixel.Width, pixel.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); var pdat = new byte[plock.Stride * plock.Height]; Marshal.Copy(plock.Scan0, pdat, 0, pdat.Length); int maxX = int.MinValue, maxY = int.MinValue, minX = int.MaxValue, minY = int.MaxValue; int index = 0; for (int y = 0; y < pixel.Height; y++) { for (int x = 0; x < pixel.Width; x++) { if (!(pdat[index] == 0 && pdat[index + 1] == 255 && pdat[index + 2] == 255)) { if (x < minX) { minX = x; } if (x > maxX) { maxX = x; } if (y < minY) { minY = y; } if (y > maxY) { maxY = y; } } index += 4; } } pixel.UnlockBits(plock); var rect = (minX == int.MaxValue) ? new Rectangle() : new Rectangle(minX, minY, (maxX - minX) + 1, (maxY - minY) + 1); var px = rect.Width * rect.Height; var locks = new BitmapData[3]; var data = new byte[3][]; var pxOut = new Microsoft.Xna.Framework.Color[px]; var depthOut = new byte[px]; for (int i = 0; i < 3; i++) { locks[i] = bmps[i].LockBits(rect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); data[i] = new byte[locks[i].Stride * locks[i].Height]; Marshal.Copy(locks[i].Scan0, data[i], 0, data[i].Length); } int scanStart = 0; int dstidx = 0; for (int y = 0; y < locks[0].Height; y++) { int srcidx = scanStart; for (int j = 0; j < rect.Width; j++) { pxOut[dstidx] = new Microsoft.Xna.Framework.Color(data[0][srcidx + 2], data[0][srcidx + 1], data[0][srcidx], data[1][srcidx]); depthOut[dstidx] = data[2][srcidx]; srcidx += 4; dstidx++; } scanStart += locks[0].Stride; } //set data first. we also want to get back the a palette we can change PALT targ = null; Microsoft.Xna.Framework.Color[] used; Content.Content.Get().Changes.BlockingResMod(new ResAction(() => { used = GraphicChunk.Frames[frame].SetData(pxOut, depthOut, rect); var ownPalt = GraphicChunk.ChunkParent.Get <PALT>(GraphicChunk.Frames[frame].PaletteID); ushort freePalt = GraphicChunk.ChunkID; if (GraphicChunk.Frames[frame].PaletteID != 0 && ownPalt != null && ownPalt.References == 1) { targ = ownPalt; } else { var palts = GraphicChunk.ChunkParent.List <PALT>(); palts = (palts == null) ? new List <PALT>() : palts.OrderBy(x => x.ChunkID).ToList(); foreach (var palt in palts) { if (palt.ChunkID == freePalt) { freePalt++; } if (palt.PalMatch(used) || palt.References == 0) { targ = palt; break; } } } if (targ != null) { //replace existing palt. lock (targ) { if (targ.References == 0 || targ == ownPalt) { targ.Colors = used; } } Content.Content.Get().Changes.ChunkChanged(targ); GraphicChunk.Frames[frame].SetPalt(targ); } else { //we need to make a new PALT. //a bit hacky for now var nPalt = new PALT() { ChunkID = freePalt, ChunkLabel = GraphicChunk.ChunkLabel + " Auto PALT", AddedByPatch = true, ChunkProcessed = true, ChunkType = "PALT", RuntimeInfo = ChunkRuntimeState.Modified, Colors = used }; GraphicChunk.ChunkParent.AddChunk(nPalt); GraphicChunk.Frames[frame].SetPalt(nPalt); Content.Content.Get().Changes.ChunkChanged(nPalt); } }, GraphicChunk)); for (int i = 0; i < 3; i++) { bmps[i].UnlockBits(locks[i]); } }
public static float[] ToFloatsArray(this IntPtr ptr, int size) { float[] result = new float[size]; Marshal.Copy(ptr, result, 0, size); return(result); }
/// <summary> /// Process each log entry /// </summary> /// <param name="packettype">packet type</param> /// <param name="br">input file</param> /// <returns>string of converted data</returns> static string logEntry(byte packettype, Stream br) { switch (packettype) { case 0x80: // FMT log_Format logfmt = new log_Format(); object obj = logfmt; int len = Marshal.SizeOf(obj); byte[] bytearray = new byte[len]; br.Read(bytearray, 0, bytearray.Length); IntPtr i = Marshal.AllocHGlobal(len); // create structure from ptr obj = Marshal.PtrToStructure(i, obj.GetType()); // copy byte array to ptr Marshal.Copy(bytearray, 0, i, len); obj = Marshal.PtrToStructure(i, obj.GetType()); Marshal.FreeHGlobal(i); logfmt = (log_Format)obj; string lgname = ASCIIEncoding.ASCII.GetString(logfmt.name).Trim(new char[] { '\0' }); string lgformat = ASCIIEncoding.ASCII.GetString(logfmt.format).Trim(new char[] { '\0' }); string lglabels = ASCIIEncoding.ASCII.GetString(logfmt.labels).Trim(new char[] { '\0' }); logformat[lgname] = logfmt; string line = String.Format("FMT, {0}, {1}, {2}, {3}, {4}\r\n", logfmt.type, logfmt.length, lgname, lgformat, lglabels); return(line); default: string format = ""; string name = ""; int size = 0; foreach (log_Format fmt in logformat.Values) { if (fmt.type == packettype) { name = ASCIIEncoding.ASCII.GetString(fmt.name).Trim(new char[] { '\0' }); format = ASCIIEncoding.ASCII.GetString(fmt.format).Trim(new char[] { '\0' }); size = fmt.length; break; } } // didnt find a match, return unknown packet type if (size == 0) { return("UNKW, " + packettype); } byte[] data = new byte[size - 3]; // size - 3 = message - messagetype - (header *2) br.Read(data, 0, data.Length); return(ProcessMessage(data, name, format)); } }
public static byte[] ToBytesArray(this IntPtr ptr, int size) { byte[] result = new byte[size]; Marshal.Copy(ptr, result, 0, size); return(result); }
public unsafe void CopyTo(IntPtr destDeviceData, int length) { Marshal.Copy(_buffer, 0, destDeviceData, length); }
private static Texture2D PlatformFromStream(GraphicsDevice graphicsDevice, Stream stream) { #if IOS || MONOMAC #if IOS using (var uiImage = UIImage.LoadFromData(NSData.FromStream(stream))) #elif MONOMAC using (var nsImage = NSImage.FromStream(stream)) #endif { #if IOS var cgImage = uiImage.CGImage; #elif MONOMAC #if PLATFORM_MACOS_LEGACY var rectangle = RectangleF.Empty; #else var rectangle = CGRect.Empty; #endif var cgImage = nsImage.AsCGImage(ref rectangle, null, null); #endif return(PlatformFromStream(graphicsDevice, cgImage)); } #endif #if ANDROID using (Bitmap image = BitmapFactory.DecodeStream(stream, null, new BitmapFactory.Options { InScaled = false, InDither = false, InJustDecodeBounds = false, InPurgeable = true, InInputShareable = true, })) { return(PlatformFromStream(graphicsDevice, image)); } #endif #if DESKTOPGL || ANGLE Bitmap image = (Bitmap)Bitmap.FromStream(stream); try { // Fix up the Image to match the expected format image = (Bitmap)image.RGBToBGR(); var data = new byte[image.Width * image.Height * 4]; BitmapData bitmapData = image.LockBits(new System.Drawing.Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); if (bitmapData.Stride != image.Width * 4) { throw new NotImplementedException(); } Marshal.Copy(bitmapData.Scan0, data, 0, data.Length); image.UnlockBits(bitmapData); Texture2D texture = null; texture = new Texture2D(graphicsDevice, image.Width, image.Height); texture.SetData(data); return(texture); } finally { image.Dispose(); } #endif }
public byte[] Export(X509ContentType contentType, String password) { switch (contentType) { case X509ContentType.Cert: { SafeCertContextHandle pCertContext = null; if (!Interop.crypt32.CertEnumCertificatesInStore(_certStore, ref pCertContext)) { return(null); } try { unsafe { byte[] rawData = new byte[pCertContext.CertContext->cbCertEncoded]; Marshal.Copy((IntPtr)(pCertContext.CertContext->pbCertEncoded), rawData, 0, rawData.Length); GC.KeepAlive(pCertContext); return(rawData); } } finally { pCertContext.Dispose(); } } case X509ContentType.SerializedCert: { SafeCertContextHandle pCertContext = null; if (!Interop.crypt32.CertEnumCertificatesInStore(_certStore, ref pCertContext)) { return(null); } try { int cbEncoded = 0; if (!Interop.crypt32.CertSerializeCertificateStoreElement(pCertContext, 0, null, ref cbEncoded)) { throw new CryptographicException(Marshal.GetHRForLastWin32Error()); } byte[] pbEncoded = new byte[cbEncoded]; if (!Interop.crypt32.CertSerializeCertificateStoreElement(pCertContext, 0, pbEncoded, ref cbEncoded)) { throw new CryptographicException(Marshal.GetHRForLastWin32Error()); } return(pbEncoded); } finally { pCertContext.Dispose(); } } case X509ContentType.Pkcs12: { unsafe { CRYPTOAPI_BLOB dataBlob = new CRYPTOAPI_BLOB(0, (byte *)null); if (!Interop.crypt32.PFXExportCertStore(_certStore, ref dataBlob, password, PFXExportFlags.EXPORT_PRIVATE_KEYS | PFXExportFlags.REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY)) { throw new CryptographicException(Marshal.GetHRForLastWin32Error()); } byte[] pbEncoded = new byte[dataBlob.cbData]; fixed(byte *ppbEncoded = pbEncoded) { dataBlob.pbData = ppbEncoded; if (!Interop.crypt32.PFXExportCertStore(_certStore, ref dataBlob, password, PFXExportFlags.EXPORT_PRIVATE_KEYS | PFXExportFlags.REPORT_NOT_ABLE_TO_EXPORT_PRIVATE_KEY)) { throw new CryptographicException(Marshal.GetHRForLastWin32Error()); } } return(pbEncoded); } } case X509ContentType.SerializedStore: return(SaveToMemoryStore(CertStoreSaveAs.CERT_STORE_SAVE_AS_STORE)); case X509ContentType.Pkcs7: return(SaveToMemoryStore(CertStoreSaveAs.CERT_STORE_SAVE_AS_PKCS7)); default: throw new CryptographicException(SR.Cryptography_X509_InvalidContentType); } }
/// <summary> /// Quantize an image and return the resulting output brush /// </summary> /// <param name="source">The image to quantize</param> /// <returns>T quantized version of the image</returns> public Bitmap Quantize(Image source) { // Get the size of the source image int height = source.Height; int width = source.Width; // And construct a rectangle from these dimensions Rectangle bounds = new Rectangle(0, 0, width, height); // First off take a 32bpp copy of the image Bitmap copy = new Bitmap(width, height, PixelFormat.Format32bppArgb); // And construct an 8bpp version Bitmap output = new Bitmap(width, height, PixelFormat.Format8bppIndexed); byte[] sourceData; // Now lock the brush into memory using (Graphics g = Graphics.FromImage(copy)) { g.PageUnit = GraphicsUnit.Pixel; // Draw the source image onto the copy brush, // which will effect a widening as appropriate. g.DrawImage(source, bounds); } // Define a pointer to the brush data BitmapData sourceLock = null; try { // Get the source image bits and lock into memory sourceLock = copy.LockBits(bounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); sourceData = new byte[sourceLock.Stride * source.Height]; Marshal.Copy(sourceLock.Scan0, sourceData, 0, sourceData.Length); // Call the FirstPass function if not a single pass algorithm. // For something like an octree quantizer, this will run through // all image pixels, build a data structure, and create a paletteIndex. if (!_singlePass) { FirstPass(sourceData, width, height, sourceLock.Stride); } // Then set the color paletteIndex on the output brush. I'm passing in the current paletteIndex // as there's no way to construct a new, empty paletteIndex. output.Palette = GetPalette(output.Palette); // Then call the second pass which actually does the conversion SecondPass(sourceData, output, width, height, bounds, sourceLock.Stride); } finally { // Ensure that the bits are unlocked copy.UnlockBits(sourceLock); } // Last but not least, return the output brush return(output); }
/// <summary> /// Sends an ATA command in 48-bit mode /// </summary> /// <returns>0 if no error occurred, otherwise, errno</returns> /// <param name="dev">CAM device</param> /// <param name="buffer">Buffer for SCSI command response</param> /// <param name="timeout">Timeout in seconds</param> /// <param name="duration">Time it took to execute the command in milliseconds</param> /// <param name="sense"><c>True</c> if ATA error returned non-OK status</param> /// <param name="registers">Registers to send to drive</param> /// <param name="errorRegisters">Registers returned by drive</param> /// <param name="protocol">ATA protocol to use</param> internal static int SendAtaCommand(IntPtr dev, AtaRegistersLba48 registers, out AtaErrorRegistersLba48 errorRegisters, AtaProtocol protocol, ref byte[] buffer, uint timeout, out double duration, out bool sense) { duration = 0; sense = false; errorRegisters = new AtaErrorRegistersLba48(); // 48-bit ATA CAM commands can crash FreeBSD < 9.2-RELEASE if (Environment.Version.Major == 9 && Environment.Version.Minor < 2 || Environment.Version.Major < 9) { return(-1); } if (buffer == null) { return(-1); } IntPtr ccbPtr = cam_getccb(dev); CcbAtaio ataio = (CcbAtaio)Marshal.PtrToStructure(ccbPtr, typeof(CcbAtaio)); ataio.ccb_h.func_code = XptOpcode.XptAtaIo; ataio.ccb_h.flags = AtaProtocolToCamFlags(protocol); ataio.ccb_h.xflags = 0; ataio.ccb_h.retry_count = 1; ataio.ccb_h.cbfcnp = IntPtr.Zero; ataio.ccb_h.timeout = timeout; ataio.data_ptr = Marshal.AllocHGlobal(buffer.Length); ataio.dxfer_len = (uint)buffer.Length; ataio.ccb_h.flags |= CcbFlags.CamDevQfrzdis; ataio.cmd.flags = CamAtaIoFlags.NeedResult | CamAtaIoFlags.ExtendedCommand; switch (protocol) { case AtaProtocol.Dma: case AtaProtocol.DmaQueued: case AtaProtocol.UDmaIn: case AtaProtocol.UDmaOut: ataio.cmd.flags |= CamAtaIoFlags.Dma; break; case AtaProtocol.FpDma: ataio.cmd.flags |= CamAtaIoFlags.Fpdma; break; } ataio.cmd.lba_high_exp = (byte)((registers.LbaHigh & 0xFF00) >> 8); ataio.cmd.lba_mid_exp = (byte)((registers.LbaMid & 0xFF00) >> 8); ataio.cmd.features_exp = (byte)((registers.Feature & 0xFF00) >> 8); ataio.cmd.sector_count_exp = (byte)((registers.SectorCount & 0xFF00) >> 8); ataio.cmd.lba_low_exp = (byte)((registers.LbaLow & 0xFF00) >> 8); ataio.cmd.lba_high = (byte)(registers.LbaHigh & 0xFF); ataio.cmd.lba_mid = (byte)(registers.LbaMid & 0xFF); ataio.cmd.features = (byte)(registers.Feature & 0xFF); ataio.cmd.sector_count = (byte)(registers.SectorCount & 0xFF); ataio.cmd.lba_low = (byte)(registers.LbaLow & 0xFF); ataio.cmd.command = registers.Command; ataio.cmd.device = (byte)(0x40 | registers.DeviceHead); Marshal.Copy(buffer, 0, ataio.data_ptr, buffer.Length); Marshal.StructureToPtr(ataio, ccbPtr, false); DateTime start = DateTime.UtcNow; int error = cam_send_ccb(dev, ccbPtr); DateTime end = DateTime.UtcNow; if (error < 0) { error = Marshal.GetLastWin32Error(); } ataio = (CcbAtaio)Marshal.PtrToStructure(ccbPtr, typeof(CcbAtaio)); if ((ataio.ccb_h.status & CamStatus.CamStatusMask) != CamStatus.CamReqCmp && (ataio.ccb_h.status & CamStatus.CamStatusMask) != CamStatus.CamScsiStatusError) { error = Marshal.GetLastWin32Error(); DicConsole.DebugWriteLine("FreeBSD devices", "CAM status {0} error {1}", ataio.ccb_h.status, error); sense = true; } if ((ataio.ccb_h.status & CamStatus.CamStatusMask) == CamStatus.CamAtaStatusError) { sense = true; } errorRegisters.SectorCount = (ushort)((ataio.res.sector_count_exp << 8) + ataio.res.sector_count); errorRegisters.LbaLow = (ushort)((ataio.res.lba_low_exp << 8) + ataio.res.lba_low); errorRegisters.LbaMid = (ushort)((ataio.res.lba_mid_exp << 8) + ataio.res.lba_mid); errorRegisters.LbaHigh = (ushort)((ataio.res.lba_high_exp << 8) + ataio.res.lba_high); errorRegisters.DeviceHead = ataio.res.device; errorRegisters.Error = ataio.res.error; errorRegisters.Status = ataio.res.status; buffer = new byte[ataio.dxfer_len]; Marshal.Copy(ataio.data_ptr, buffer, 0, buffer.Length); duration = (end - start).TotalMilliseconds; Marshal.FreeHGlobal(ataio.data_ptr); cam_freeccb(ccbPtr); sense = errorRegisters.Error != 0 || (errorRegisters.Status & 0xA5) != 0 || error != 0; return(error); }
public static void SetValue(this Mat mat, int row, int col, dynamic value) { var target = CreateElement(mat.Depth, value); Marshal.Copy(target, 0, mat.DataPointer + (row * mat.Cols + col) * mat.ElementSize, 1); }
/// <summary> /// Sends a SCSI command (64-bit arch) /// </summary> /// <returns>0 if no error occurred, otherwise, errno</returns> /// <param name="dev">CAM device</param> /// <param name="cdb">SCSI CDB</param> /// <param name="buffer">Buffer for SCSI command response</param> /// <param name="senseBuffer">Buffer with the SCSI sense</param> /// <param name="timeout">Timeout in seconds</param> /// <param name="direction">SCSI command transfer direction</param> /// <param name="duration">Time it took to execute the command in milliseconds</param> /// <param name="sense"> /// <c>True</c> if SCSI error returned non-OK status and <paramref name="senseBuffer" /> contains SCSI /// sense /// </param> internal static int SendScsiCommand64(IntPtr dev, byte[] cdb, ref byte[] buffer, out byte[] senseBuffer, uint timeout, CcbFlags direction, out double duration, out bool sense) { senseBuffer = null; duration = 0; sense = false; if (buffer == null) { return(-1); } IntPtr ccbPtr = cam_getccb(dev); IntPtr cdbPtr = IntPtr.Zero; if (ccbPtr.ToInt64() == 0) { sense = true; return(Marshal.GetLastWin32Error()); } CcbScsiio64 csio = (CcbScsiio64)Marshal.PtrToStructure(ccbPtr, typeof(CcbScsiio64)); csio.ccb_h.func_code = XptOpcode.XptScsiIo; csio.ccb_h.flags = direction; csio.ccb_h.xflags = 0; csio.ccb_h.retry_count = 1; csio.ccb_h.cbfcnp = IntPtr.Zero; csio.ccb_h.timeout = timeout; csio.data_ptr = Marshal.AllocHGlobal(buffer.Length); csio.dxfer_len = (uint)buffer.Length; csio.sense_len = 32; csio.cdb_len = (byte)cdb.Length; // TODO: Create enum? csio.tag_action = 0x20; csio.cdb_bytes = new byte[CAM_MAX_CDBLEN]; if (cdb.Length <= CAM_MAX_CDBLEN) { Array.Copy(cdb, 0, csio.cdb_bytes, 0, cdb.Length); } else { cdbPtr = Marshal.AllocHGlobal(cdb.Length); byte[] cdbPtrBytes = BitConverter.GetBytes(cdbPtr.ToInt64()); Array.Copy(cdbPtrBytes, 0, csio.cdb_bytes, 0, IntPtr.Size); csio.ccb_h.flags |= CcbFlags.CamCdbPointer; } csio.ccb_h.flags |= CcbFlags.CamDevQfrzdis; Marshal.Copy(buffer, 0, csio.data_ptr, buffer.Length); Marshal.StructureToPtr(csio, ccbPtr, false); DateTime start = DateTime.UtcNow; int error = cam_send_ccb(dev, ccbPtr); DateTime end = DateTime.UtcNow; if (error < 0) { error = Marshal.GetLastWin32Error(); } csio = (CcbScsiio64)Marshal.PtrToStructure(ccbPtr, typeof(CcbScsiio64)); if ((csio.ccb_h.status & CamStatus.CamStatusMask) != CamStatus.CamReqCmp && (csio.ccb_h.status & CamStatus.CamStatusMask) != CamStatus.CamScsiStatusError) { error = Marshal.GetLastWin32Error(); DicConsole.DebugWriteLine("FreeBSD devices", "CAM status {0} error {1}", csio.ccb_h.status, error); sense = true; } if ((csio.ccb_h.status & CamStatus.CamStatusMask) == CamStatus.CamScsiStatusError) { sense = true; senseBuffer = new byte[1]; senseBuffer[0] = csio.scsi_status; } if ((csio.ccb_h.status & CamStatus.CamAutosnsValid) != 0) { if (csio.sense_len - csio.sense_resid > 0) { sense = (csio.ccb_h.status & CamStatus.CamStatusMask) == CamStatus.CamScsiStatusError; senseBuffer = new byte[csio.sense_len - csio.sense_resid]; senseBuffer[0] = csio.sense_data.error_code; Array.Copy(csio.sense_data.sense_buf, 0, senseBuffer, 1, senseBuffer.Length - 1); } } buffer = new byte[csio.dxfer_len]; cdb = new byte[csio.cdb_len]; Marshal.Copy(csio.data_ptr, buffer, 0, buffer.Length); if (csio.ccb_h.flags.HasFlag(CcbFlags.CamCdbPointer)) { Marshal.Copy(new IntPtr(BitConverter.ToInt64(csio.cdb_bytes, 0)), cdb, 0, cdb.Length); } else { Array.Copy(csio.cdb_bytes, 0, cdb, 0, cdb.Length); } duration = (end - start).TotalMilliseconds; if (csio.ccb_h.flags.HasFlag(CcbFlags.CamCdbPointer)) { Marshal.FreeHGlobal(cdbPtr); } Marshal.FreeHGlobal(csio.data_ptr); cam_freeccb(ccbPtr); return(error); }
public void CopyTo_NullDestination_ThrowsArgumentNullException() { AssertExtensions.Throws <ArgumentNullException>("destination", () => Marshal.Copy(new short[10], 0, IntPtr.Zero, 0)); AssertExtensions.Throws <ArgumentNullException>("destination", () => Marshal.Copy(new IntPtr(1), (short[])null, 0, 0)); }
static unsafe void Initialize() { uint old; Module module = typeof(AntiDump).Module; var bas = (byte *)Marshal.GetHINSTANCE(module); byte * ptr = bas + 0x3c; byte * ptr2; ptr = ptr2 = bas + *(uint *)ptr; ptr += 0x6; ushort sectNum = *(ushort *)ptr; ptr += 14; ushort optSize = *(ushort *)ptr; ptr = ptr2 = ptr + 0x4 + optSize; byte * @new = stackalloc byte[11]; if (module.FullyQualifiedName[0] != '<') //Mapped { //VirtualProtect(ptr - 16, 8, 0x40, out old); //*(uint*)(ptr - 12) = 0; byte *mdDir = bas + *(uint *)(ptr - 16); //*(uint*)(ptr - 16) = 0; if (*(uint *)(ptr - 0x78) != 0) { byte *importDir = bas + *(uint *)(ptr - 0x78); byte *oftMod = bas + *(uint *)importDir; byte *modName = bas + *(uint *)(importDir + 12); byte *funcName = bas + *(uint *)oftMod + 2; VirtualProtect(modName, 11, 0x40, out old); *(uint *)@new = 0x6c64746e; *((uint *)@new + 1) = 0x6c642e6c; *((ushort *)@new + 4) = 0x006c; *(@new + 10) = 0; for (int i = 0; i < 11; i++) { *(modName + i) = *(@new + i); } VirtualProtect(funcName, 11, 0x40, out old); *(uint *)@new = 0x6f43744e; *((uint *)@new + 1) = 0x6e69746e; *((ushort *)@new + 4) = 0x6575; *(@new + 10) = 0; for (int i = 0; i < 11; i++) { *(funcName + i) = *(@new + i); } } for (int i = 0; i < sectNum; i++) { VirtualProtect(ptr, 8, 0x40, out old); Marshal.Copy(new byte[8], 0, (IntPtr)ptr, 8); ptr += 0x28; } VirtualProtect(mdDir, 0x48, 0x40, out old); byte *mdHdr = bas + *(uint *)(mdDir + 8); *(uint *)mdDir = 0; *((uint *)mdDir + 1) = 0; *((uint *)mdDir + 2) = 0; *((uint *)mdDir + 3) = 0; VirtualProtect(mdHdr, 4, 0x40, out old); *(uint *)mdHdr = 0; mdHdr += 12; mdHdr += *(uint *)mdHdr; mdHdr = (byte *)(((ulong)mdHdr + 7) & ~3UL); mdHdr += 2; ushort numOfStream = *mdHdr; mdHdr += 2; for (int i = 0; i < numOfStream; i++) { VirtualProtect(mdHdr, 8, 0x40, out old); //*(uint*)mdHdr = 0; mdHdr += 4; //*(uint*)mdHdr = 0; mdHdr += 4; for (int ii = 0; ii < 8; ii++) { VirtualProtect(mdHdr, 4, 0x40, out old); *mdHdr = 0; mdHdr++; if (*mdHdr == 0) { mdHdr += 3; break; } *mdHdr = 0; mdHdr++; if (*mdHdr == 0) { mdHdr += 2; break; } *mdHdr = 0; mdHdr++; if (*mdHdr == 0) { mdHdr += 1; break; } *mdHdr = 0; mdHdr++; } } } else //Flat { //VirtualProtect(ptr - 16, 8, 0x40, out old); //*(uint*)(ptr - 12) = 0; uint mdDir = *(uint *)(ptr - 16); //*(uint*)(ptr - 16) = 0; uint importDir = *(uint *)(ptr - 0x78); var vAdrs = new uint[sectNum]; var vSizes = new uint[sectNum]; var rAdrs = new uint[sectNum]; for (int i = 0; i < sectNum; i++) { VirtualProtect(ptr, 8, 0x40, out old); Marshal.Copy(new byte[8], 0, (IntPtr)ptr, 8); vAdrs[i] = *(uint *)(ptr + 12); vSizes[i] = *(uint *)(ptr + 8); rAdrs[i] = *(uint *)(ptr + 20); ptr += 0x28; } if (importDir != 0) { for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= importDir && importDir < vAdrs[i] + vSizes[i]) { importDir = importDir - vAdrs[i] + rAdrs[i]; break; } } byte *importDirPtr = bas + importDir; uint oftMod = *(uint *)importDirPtr; for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= oftMod && oftMod < vAdrs[i] + vSizes[i]) { oftMod = oftMod - vAdrs[i] + rAdrs[i]; break; } } byte *oftModPtr = bas + oftMod; uint modName = *(uint *)(importDirPtr + 12); for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= modName && modName < vAdrs[i] + vSizes[i]) { modName = modName - vAdrs[i] + rAdrs[i]; break; } } uint funcName = *(uint *)oftModPtr + 2; for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= funcName && funcName < vAdrs[i] + vSizes[i]) { funcName = funcName - vAdrs[i] + rAdrs[i]; break; } } VirtualProtect(bas + modName, 11, 0x40, out old); *(uint *)@new = 0x6c64746e; *((uint *)@new + 1) = 0x6c642e6c; *((ushort *)@new + 4) = 0x006c; *(@new + 10) = 0; for (int i = 0; i < 11; i++) { *(bas + modName + i) = *(@new + i); } VirtualProtect(bas + funcName, 11, 0x40, out old); *(uint *)@new = 0x6f43744e; *((uint *)@new + 1) = 0x6e69746e; *((ushort *)@new + 4) = 0x6575; *(@new + 10) = 0; for (int i = 0; i < 11; i++) { *(bas + funcName + i) = *(@new + i); } } for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= mdDir && mdDir < vAdrs[i] + vSizes[i]) { mdDir = mdDir - vAdrs[i] + rAdrs[i]; break; } } byte *mdDirPtr = bas + mdDir; VirtualProtect(mdDirPtr, 0x48, 0x40, out old); uint mdHdr = *(uint *)(mdDirPtr + 8); for (int i = 0; i < sectNum; i++) { if (vAdrs[i] <= mdHdr && mdHdr < vAdrs[i] + vSizes[i]) { mdHdr = mdHdr - vAdrs[i] + rAdrs[i]; break; } } *(uint *)mdDirPtr = 0; *((uint *)mdDirPtr + 1) = 0; *((uint *)mdDirPtr + 2) = 0; *((uint *)mdDirPtr + 3) = 0; byte *mdHdrPtr = bas + mdHdr; VirtualProtect(mdHdrPtr, 4, 0x40, out old); *(uint *)mdHdrPtr = 0; mdHdrPtr += 12; mdHdrPtr += *(uint *)mdHdrPtr; mdHdrPtr = (byte *)(((ulong)mdHdrPtr + 7) & ~3UL); mdHdrPtr += 2; ushort numOfStream = *mdHdrPtr; mdHdrPtr += 2; for (int i = 0; i < numOfStream; i++) { VirtualProtect(mdHdrPtr, 8, 0x40, out old); //*(uint*)mdHdrPtr = 0; mdHdrPtr += 4; //*(uint*)mdHdrPtr = 0; mdHdrPtr += 4; for (int ii = 0; ii < 8; ii++) { VirtualProtect(mdHdrPtr, 4, 0x40, out old); *mdHdrPtr = 0; mdHdrPtr++; if (*mdHdrPtr == 0) { mdHdrPtr += 3; break; } *mdHdrPtr = 0; mdHdrPtr++; if (*mdHdrPtr == 0) { mdHdrPtr += 2; break; } *mdHdrPtr = 0; mdHdrPtr++; if (*mdHdrPtr == 0) { mdHdrPtr += 1; break; } *mdHdrPtr = 0; mdHdrPtr++; } } } }
public void CopyTo_NegativeLength_ThrowsArgumentOutOfRangeException() { short[] array = new short[10]; IntPtr ptr = Marshal.AllocCoTaskMem(sizeof(short) * array.Length); try { AssertExtensions.Throws <ArgumentOutOfRangeException>(null, () => Marshal.Copy(array, 0, ptr, -1)); AssertExtensions.Throws <ArgumentOutOfRangeException>("length", () => Marshal.Copy(ptr, array, 0, -1)); } finally { Marshal.FreeCoTaskMem(ptr); } }
private ServiceElement BuildElement(IntPtr pElemData) { var elemData = (Structs.SDP_Data_Element)Marshal.PtrToStructure( pElemData, typeof(Structs.SDP_Data_Element)); var sizeofElemData = Marshal.SizeOf(typeof(Structs.SDP_Data_Element)); // ElementTypeDescriptor etd; SizeIndex sizeIndex; Map(elemData.SDP_Data_Element_Type, out etd, out sizeIndex); // const int OffsetOf_FakeAtUnionPosition = 8; #if !NETCF var dbgOffset = Marshal.OffsetOf(typeof(Structs.SDP_Data_Element), "FakeAtUnionPosition"); Debug.Assert(new IntPtr(OffsetOf_FakeAtUnionPosition) == dbgOffset, "OffsetOf_FakeAtUnionPosition but: " + dbgOffset); #endif IntPtr pDataInStruct = Pointers.Add(pElemData, OffsetOf_FakeAtUnionPosition); IntPtr pArrElements = Marshal.ReadIntPtr(pDataInStruct); if (etd == ElementTypeDescriptor.ElementSequence || etd == ElementTypeDescriptor.ElementAlternative) { var list = new List <ServiceElement>(); var pCur = pArrElements; for (int i = 0; i < elemData.SDP_Data_Element_Length; ++i) { var e = BuildElement(pCur); list.Add(e); // Next pCur = Pointers.Add(pCur, sizeofElemData); }//for #if DEBUG ElementTypeDescriptor cover; if (etd == ElementTypeDescriptor.ElementAlternative) { cover = etd; //COVERAGE } else { cover = etd; //COVERAGE } #endif return(new ServiceElement( etd == ElementTypeDescriptor.ElementSequence ? ElementType.ElementSequence : ElementType.ElementAlternative, list)); } else { byte[] buf = new byte[elemData.SDP_Data_Element_Length]; IntPtr pData; if (etd == ElementTypeDescriptor.TextString || etd == ElementTypeDescriptor.Url) { pData = pArrElements; } else { pData = pDataInStruct; } Marshal.Copy(pData, buf, 0, buf.Length); int readLen = buf.Length; var elem = _parser.ParseContent(false, true, buf, 0, buf.Length, ref readLen, etd, sizeIndex, buf.Length, 0); return(elem); } }
/// <summary> /// Loads a mesh and creates the vertex/index buffers for the part /// </summary> /// <param name="part"></param> /// <param name="meshData"></param> void LoadMesh(ref Part part, IXDataObject dataObject) { // load vertex data int dataOffset = 0; Match vertexCount = findArrayCount.Match(dataObject.Body); if(!vertexCount.Success) throw new System.IO.InvalidDataException("problem reading vertex count"); List<Vector4F> vertexList = new List<Vector4F>(); int verticies = int.Parse(vertexCount.Groups[1].Value, CultureInfo.InvariantCulture); dataOffset = vertexCount.Index + vertexCount.Length; for(int vertexIndex = 0; vertexIndex < verticies; vertexIndex++) { Match vertex = findVector3F.Match(dataObject.Body, dataOffset); if(!vertex.Success) throw new System.IO.InvalidDataException("problem reading vertex"); else dataOffset = vertex.Index + vertex.Length; vertexList.Add( new Vector4F( float.Parse(vertex.Groups[1].Value, CultureInfo.InvariantCulture), float.Parse(vertex.Groups[2].Value, CultureInfo.InvariantCulture), float.Parse(vertex.Groups[3].Value, CultureInfo.InvariantCulture), 1.0f)); } // load triangle index data Match triangleIndexCount = findArrayCount.Match(dataObject.Body, dataOffset); dataOffset = triangleIndexCount.Index + triangleIndexCount.Length; if(!triangleIndexCount.Success) throw new System.IO.InvalidDataException("problem reading index count"); List<Int32> triangleIndiciesList = new List<Int32>(); int triangleIndexListCount = int.Parse(triangleIndexCount.Groups[1].Value, CultureInfo.InvariantCulture); dataOffset = triangleIndexCount.Index + triangleIndexCount.Length; for(int triangleIndicyIndex = 0; triangleIndicyIndex < triangleIndexListCount; triangleIndicyIndex++) { Match indexEntry = findVertexIndex.Match(dataObject.Body, dataOffset); if(!indexEntry.Success) throw new System.IO.InvalidDataException("problem reading vertex index entry"); else dataOffset = indexEntry.Index + indexEntry.Length; int indexEntryCount = int.Parse(indexEntry.Groups[1].Value, CultureInfo.InvariantCulture); string[] vertexIndexes = indexEntry.Groups[2].Value.Split(new char[] { ',' }); if(indexEntryCount != vertexIndexes.Length) throw new System.IO.InvalidDataException("vertex index count does not equal count of indicies found"); for(int entryIndex = 0; entryIndex <= indexEntryCount - 3; entryIndex++) { triangleIndiciesList.Add(int.Parse(vertexIndexes[0], CultureInfo.InvariantCulture)); triangleIndiciesList.Add(int.Parse(vertexIndexes[1 + entryIndex].ToString(), CultureInfo.InvariantCulture)); triangleIndiciesList.Add(int.Parse(vertexIndexes[2 + entryIndex].ToString(), CultureInfo.InvariantCulture)); } } // load mesh colors IXDataObject vertexColorData = GetSingleChild(dataObject, "MeshVertexColors"); Dictionary<int, Vector4F> colorDictionary = null; if (vertexColorData != null) colorDictionary = LoadMeshColors(vertexColorData); // load mesh normals IXDataObject meshNormalData = GetSingleChild(dataObject, "MeshNormals"); IndexedMeshNormals meshNormals = null; if(meshNormalData != null) { meshNormals = LoadMeshNormals(meshNormalData); } // load mesh texture coordinates IXDataObject meshTextureCoordsData = GetSingleChild(dataObject, "MeshTextureCoords"); List<Vector2F> meshTextureCoords = null; if(meshTextureCoordsData != null) { meshTextureCoords = LoadMeshTextureCoordinates(meshTextureCoordsData); } // load mesh material IXDataObject meshMaterialsData = GetSingleChild(dataObject, "MeshMaterialList"); List<MaterialSpecification> meshMaterials = null; if(meshMaterialsData != null) { meshMaterials = LoadMeshMaterialList(meshMaterialsData); } // copy vertex data to HGLOBAL int byteLength = Marshal.SizeOf(typeof(XMeshVertex)) * triangleIndiciesList.Count; IntPtr nativeVertex = Marshal.AllocHGlobal(byteLength); byte[] byteBuffer = new byte[byteLength]; XMeshVertex[] varray = new XMeshVertex[triangleIndiciesList.Count]; for(int n = 0; n < triangleIndiciesList.Count; n++) { XMeshVertex vertex = new XMeshVertex() { Vertex = vertexList[triangleIndiciesList[n]], Normal = (meshNormals == null) ? new Vector4F(0, 0, 0, 1.0f) : meshNormals.normalVectors[meshNormals.normalIndexMap[n]], Color = ((colorDictionary == null) ? new Vector4F(0, 0, 0, 0) : colorDictionary[triangleIndiciesList[n]]), Texture = ((meshTextureCoords == null) ? new Vector2F(0, 0) : meshTextureCoords[triangleIndiciesList[n]]) }; byte[] vertexData = RawSerialize(vertex); Buffer.BlockCopy(vertexData, 0, byteBuffer, vertexData.Length * n, vertexData.Length); } Marshal.Copy(byteBuffer, 0, nativeVertex, byteLength); // build vertex buffer BufferDescription bdv = new BufferDescription() { Usage = Usage.Default, ByteWidth = (uint)(Marshal.SizeOf(typeof(XMeshVertex)) * triangleIndiciesList.Count), BindingOptions = BindingOptions.VertexBuffer, CpuAccessOptions = CpuAccessOptions.None, MiscellaneousResourceOptions = MiscellaneousResourceOptions.None }; SubresourceData vertexInit = new SubresourceData() { SystemMemory = nativeVertex }; part.vertexBuffer = device.CreateBuffer(bdv, vertexInit); Debug.Assert(part.vertexBuffer != null); part.vertexCount = triangleIndiciesList.Count; if(meshMaterials != null) { // only a single material is currently supported MaterialSpecification m = meshMaterials[0]; part.material = new Material() { emissiveColor = m.emissiveColor, specularColor = m.specularColor, materialColor = m.materialColor, specularPower = m.specularPower }; string texturePath = ""; if(File.Exists(m.textureFileName)) texturePath = m.textureFileName; if(File.Exists(meshDirectory + "\\" + m.textureFileName)) texturePath = meshDirectory + "\\" + m.textureFileName; if(File.Exists(meshDirectory + "\\..\\" + m.textureFileName)) texturePath = meshDirectory + "\\..\\" + m.textureFileName; if(texturePath.Length == 0) { part.material.textureResource = null; } else { part.material.textureResource = D3D10XHelpers.CreateShaderResourceViewFromFile( device, texturePath); } } Marshal.FreeHGlobal(nativeVertex); }
public byte[] ToArray() { byte[] data = new byte[count]; Marshal.Copy(new IntPtr(this.data), data, 0, count); return(data); }