public unsafe ITexture2D Load(string fileName) { ITexture2D result; var bitmap = new Bitmap(fileName); var data = new byte[bitmap.Width * bitmap.Height * 4 * 2]; var mipPointers = new IntPtr[GetMipCount(bitmap.Width, bitmap.Height)]; fixed (byte* pData = data) { mipPointers[0] = (IntPtr)pData; var bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); { var dst = pData; var src = (byte*)bitmapData.Scan0; if (bgra) { for (int y = 0; y < bitmap.Height; y++) { for (int x = 0; x < bitmap.Width; x++) { dst[0] = src[0]; dst[1] = src[1]; dst[2] = src[2]; dst[3] = 255; src += 3; dst += 4; } } } else { for (int y = 0; y < bitmap.Height; y++) { for (int x = 0; x < bitmap.Width; x++) { dst[0] = src[2]; dst[1] = src[1]; dst[2] = src[0]; dst[3] = 255; src += 3; dst += 4; } } } int mipWidth = bitmap.Width; int mipHeight = bitmap.Height; for (int level = 1; level < mipPointers.Length; level++) { mipPointers[level] = (IntPtr)dst; src = (byte*)mipPointers[level - 1]; int srcRowSpan = mipWidth * 4; mipWidth = Math.Max(mipWidth / 2, 1); mipHeight = Math.Max(mipHeight / 2, 1); for (int y = 0; y < mipHeight; y++) { for (int x = 0; x < mipWidth; x++) { for (int i = 0; i < 3; i++) { float tl = SrgbToLinear(src[i] / 255f); float tr = SrgbToLinear(src[i + 4] / 255f); float bl = SrgbToLinear(src[i + srcRowSpan] / 255f); float br = SrgbToLinear(src[i + 4 + srcRowSpan] / 255f); dst[i] = (byte)(LinearToSrgb((tl + tr + bl + br) / 4f) * 255.9999f); } dst[3] = 255; src += 8; dst += 4; } src += srcRowSpan; } } } bitmap.UnlockBits(bitmapData); var desc = new Texture2DDescription { Width = bitmap.Width, Height = bitmap.Height, ArraySize = 1, MipLevels = mipPointers.Length, FormatID = formatId, Sampling = Sampling.NoMultisampling, BindFlags = BindFlags.ShaderResource, Usage = Usage.Immutable }; result = device.Create.Texture2D(desc, mipPointers.Select(x => new SubresourceData(x, 1)).ToArray()); } return result; }
static int[] GetJobObjectProcessIds(SafeJobObjectHandle handle) { const int JobCountIncrement = 5; int numberOfAssignedProcessesOffset = Marshal.OffsetOf(typeof(NativeMethods.JobObjectBasicProcessIdList), "NumberOfAssignedProcesses").ToInt32(); int numberOfProcessIdsInListOffset = Marshal.OffsetOf(typeof(NativeMethods.JobObjectBasicProcessIdList), "NumberOfProcessIdsInList").ToInt32(); int firstProcessIdOffset = Marshal.OffsetOf(typeof(NativeMethods.JobObjectBasicProcessIdList), "FirstProcessId").ToInt32(); int numberOfProcessesInJob = JobCountIncrement; do { int infoSize = firstProcessIdOffset + (IntPtr.Size * numberOfProcessesInJob); IntPtr infoPtr = IntPtr.Zero; try { infoPtr = Marshal.AllocHGlobal(infoSize); NativeMethods.FillMemory(infoPtr, (IntPtr)infoSize, 0); Marshal.WriteInt32(infoPtr, numberOfAssignedProcessesOffset, numberOfProcessesInJob); Marshal.WriteInt32(infoPtr, numberOfProcessIdsInListOffset, 0); if (!NativeMethods.QueryInformationJobObject( handle, NativeMethods.JobObjectInfoClass.JobObjectBasicProcessIdList, infoPtr, infoSize, IntPtr.Zero)) { var error = Marshal.GetLastWin32Error(); if (error == NativeMethods.Constants.ERROR_MORE_DATA) { numberOfProcessesInJob += JobCountIncrement; continue; } throw new Win32Exception(error); } int count = Marshal.ReadInt32(infoPtr, numberOfProcessIdsInListOffset); if (count == 0) return new int[0]; IntPtr[] ids = new IntPtr[count]; Marshal.Copy(infoPtr + firstProcessIdOffset, ids, 0, count); return ids.Select(id => id.ToInt32()).ToArray(); } finally { if (infoPtr != IntPtr.Zero) Marshal.FreeHGlobal(infoPtr); } } while (true); }
private dynamic generic_ndarray_function(IntPtr funcHandle, List <string> arguments, InvokeMemberBinder binder, object[] args) { var csharpBinder = binder.GetType().GetInterface("Microsoft.CSharp.RuntimeBinder.ICSharpInvokeOrInvokeMemberBinder"); var argumentInfos = ((IList <CSharpArgumentInfo>)csharpBinder.GetProperty("ArgumentInfo").GetValue(binder, null)).Skip(1).ToList(); var namedArgumentProperty = typeof(CSharpArgumentInfo).GetProperty("NamedArgument", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty); var nametProperty = typeof(CSharpArgumentInfo).GetProperty("Name", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.GetProperty); Debug.Assert(argumentInfos != null, "argumentInfos != null"); var nonamarg = argumentInfos.Where(w => !(bool)namedArgumentProperty.GetValue(w, null)).ToList(); var namarg = argumentInfos.Select((x, i) => new { x, i }).Where(w => (bool)namedArgumentProperty.GetValue(w.x, null)) .ToDictionary(k => nametProperty.GetValue(k.x, null) as string, v => args[v.i]).ToList(); List <NDArrayHandle> nd_args = new List <NDArrayHandle>(); List <NDArrayHandle> output_vars = new List <NDArrayHandle>(); List <string> sparam_vals = new List <string>(); List <string> sparam_keys = new List <string>(); int pos_param_arg = 0; for (int i = 0; i < nonamarg.Count; i++) { if (args[i] is NdArray) { nd_args.Add(((NdArray)args[i]).Handle); } else { if (pos_param_arg >= arguments.Count) { throw new ArgumentException("Too many positional arguments"); } sparam_vals.Add(args[i].ToString()); sparam_keys.Add(arguments[pos_param_arg]); pos_param_arg = pos_param_arg + 1; } } dynamic original_output = null; foreach (var kviem in namarg) { if (kviem.Key == "out") { original_output = kviem.Value; if (kviem.Value is NdArray) { output_vars.Add(((NdArray)kviem.Value).Handle); } else { foreach (var v in (IEnumerable)kviem.Value) { if (!(v is NdArray)) { throw new ArgumentException("out need to be of type NDArray"); } output_vars.Add(((NdArray)v).Handle); } } } else { sparam_vals.Add(kviem.Value.ToString()); sparam_keys.Add(kviem.Key); } } int num_output = output_vars.Count; bool nooutput = num_output == 0; GCHandle?outputArrayGch = null; NDArrayHandle[] outputArray = null; IntPtr outputArrayPtr; if (nooutput) { outputArrayPtr = IntPtr.Zero; } else { outputArray = output_vars.ToArray(); outputArrayGch = GCHandle.Alloc(outputArray, GCHandleType.Pinned); outputArrayPtr = outputArrayGch.Value.AddrOfPinnedObject(); } NativeMethods.MXImperativeInvoke(funcHandle, nd_args.Count, nd_args.ToArray(), ref num_output, ref outputArrayPtr, sparam_keys.Count, sparam_keys.ToArray(), sparam_vals.ToArray()); if (!nooutput) { outputArrayGch.Value.Free(); } if (original_output != null) { return(original_output); } if (nooutput) { NDArrayHandle[] ndArrays = new NDArrayHandle[num_output]; Marshal.Copy(outputArrayPtr, ndArrays, 0, num_output); if (num_output == 1) { return(new NdArray(ndArrays[0])); } else { return((IList <NdArray>)ndArrays.Select(s => new NdArray(s)).ToList()); } } else { if (num_output == 1) { return(new NdArray(outputArray[0])); } else { return((IList <NdArray>)outputArray.Select(s => new NdArray(s)).ToList()); } } }
public static IdList[] APidlToIdListArray(IntPtr apidl, int count) { var pidls = new IntPtr[count]; Marshal.Copy(apidl, pidls, 0, count); return pidls.Select(PidlToIdlist).ToArray(); }
/// <summary> Query if 'wand' is magick wand. </summary> /// <param name="wand"> The wand. </param> /// <returns> true if magick wand, false if not. </returns> /*private static bool IsMagickWand(IntPtr wand) { return WandInterop.IsMagickWand(wand); }*/ /// <summary> Command genesis. </summary> /// <param name="image_info"> Information describing the image. </param> /// <param name="command"> The command. </param> /// <param name="argc"> The argc. </param> /// <param name="argv"> The argv. </param> /// <param name="metadata"> The metadata. </param> /// <param name="exception"> The exception. </param> /// <returns> true if it succeeds, false if it fails. </returns> /*private static bool CommandGenesis(IntPtr image_info, MagickCommandType command, int argc, string[] argv, byte[] metadata, IntPtr exception) { return WandInterop.MagickCommandGenesis(image_info, command, argc, argv, metadata, ref exception); //return WandInterop.MagickCommandGenesis(image_info, command, argc, argv); }*/ /// <summary> Queries the formats. </summary> /// <param name="pattern"> Specifies the pattern. </param> /// <returns> An array of string. </returns> internal static List<string> QueryFormats(string pattern) { EnsureInitialized(); IntPtr number_formats = IntPtr.Zero; IntPtr format = WandInterop.MagickQueryFormats("*", ref number_formats); IntPtr[] rowArray = new IntPtr[(int)number_formats]; Marshal.Copy(format, rowArray, 0, (int)number_formats); List<string> val = rowArray.Select(x => WandNativeString.Load(x)).ToList(); if (pattern == "*") return val; return val.FindAll(x => x.Equals(pattern, StringComparison.InvariantCultureIgnoreCase)); }
internal static IEnumerable<CREDENTIAL> CredEnumerate() { int count; IntPtr pCredentials; var ret = CredEnumerate(null, 0, out count, out pCredentials); if (ret == false) throw new Exception("Failed to enumerate credentials"); var credentials = new IntPtr[count]; for (var n = 0; n < count; n++) credentials[n] = Marshal.ReadIntPtr(pCredentials, n * Marshal.SizeOf(typeof(IntPtr))); return credentials.Select(ptr => (CREDENTIAL)Marshal.PtrToStructure(ptr, typeof(CREDENTIAL))); }
private IReadOnlyList<IVkPhysicalDevice> EnumeratePhysicalDevices() { int count; Direct.EnumeratePhysicalDevices(Handle, &count, (IntPtr*)0).CheckSuccess(); var rawArray = new IntPtr[count]; fixed (IntPtr* pRawArray = rawArray) { Direct.EnumeratePhysicalDevices(Handle, &count, pRawArray).CheckSuccess(); } return rawArray.Select(x => new VkPhysicalDevice(this, x)).ToArray(); }