Example #1
0
        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;
        }
Example #2
0
        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);
        }
Example #3
0
        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());
                }
            }
        }
Example #4
0
 public static IdList[] APidlToIdListArray(IntPtr apidl, int count)
 {
     var pidls = new IntPtr[count];
     Marshal.Copy(apidl, pidls, 0, count);
     return pidls.Select(PidlToIdlist).ToArray();
 }
Example #5
0
 /// <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)));
        }
Example #7
0
 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();
 }