コード例 #1
0
        private static SharpDX.Direct2D1.Bitmap SDXBitmapFromSysBitmap(SharpDX.Direct2D1.WindowRenderTarget device, System.Drawing.Bitmap bitmap)
        {
            var sourceArea       = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height);
            var bitmapProperties = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied));
            var size             = new SharpDX.Size2(bitmap.Width, bitmap.Height);

            // Transform pixels from BGRA to RGBA
            int stride = bitmap.Width * sizeof(int);

            using (var tempStream = new SharpDX.DataStream(bitmap.Height * stride, true, true))
            {
                // Lock System.Drawing.Bitmap
                var bitmapData = bitmap.LockBits(sourceArea, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);

                // Convert all pixels
                for (int y = 0; y < bitmap.Height; y++)
                {
                    int offset = bitmapData.Stride * y;
                    for (int x = 0; x < bitmap.Width; x++)
                    {
                        // Not optimized
                        byte B    = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte G    = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte R    = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte A    = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        int  rgba = R | (G << 8) | (B << 16) | (A << 24);
                        tempStream.Write(rgba);
                    }
                }
                bitmap.UnlockBits(bitmapData);
                tempStream.Position = 0;

                return(new SharpDX.Direct2D1.Bitmap(device, size, tempStream, stride, bitmapProperties));
            }
        }
コード例 #2
0
ファイル: Program.cs プロジェクト: lindexi/lindexi_gd
    public void Init(Window window)
    {
        var factory = new D2D.Factory();

        var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Ignore);

        var renderTargetProperties = new D2D.RenderTargetProperties
                                     (
            // 默认的行为就是尝试使用硬件优先,否则再使用软件
            D2D.RenderTargetType.Default,
            // 像素格式,对于当前大多数显卡来说,选择 B8G8R8A8 是完全能支持的
            // 而且也方便和其他框架,如 WPF 交互
            pixelFormat,
            dpiX: 96,
            dpiY: 96,
            D2D.RenderTargetUsage.None,
            D2D.FeatureLevel.Level_DEFAULT
                                     );
        var hwndRenderTargetProperties = new D2D.HwndRenderTargetProperties();

        hwndRenderTargetProperties.Hwnd      = new WindowInteropHelper(window).Handle;
        hwndRenderTargetProperties.PixelSize = new Size2((int)window.ActualWidth, (int)window.ActualHeight);

        var renderTarget = new D2D.WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties);
    }
コード例 #3
0
        private SharpDX.Direct2D1.Bitmap SDXBitmapFromSysBitmap(WindowRenderTarget device, System.Drawing.Bitmap bitmap)
        {
            var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height);
            var bitmapProperties = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied));
            var size = new Size2(bitmap.Width, bitmap.Height);

            // Transform pixels from BGRA to RGBA
            int stride = bitmap.Width * sizeof(int);
            using (var tempStream = new DataStream(bitmap.Height * stride, true, true))
            {
                // Lock System.Drawing.Bitmap
                var bitmapData = bitmap.LockBits(sourceArea, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);

                // Convert all pixels 
                for (int y = 0; y < bitmap.Height; y++)
                {
                    int offset = bitmapData.Stride * y;
                    for (int x = 0; x < bitmap.Width; x++)
                    {
                        // Not optimized 
                        byte B = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte G = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte R = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        byte A = Marshal.ReadByte(bitmapData.Scan0, offset++);
                        int rgba = R | (G << 8) | (B << 16) | (A << 24);
                        tempStream.Write(rgba);
                    }

                }
                bitmap.UnlockBits(bitmapData);
                tempStream.Position = 0;

                return new SharpDX.Direct2D1.Bitmap(device, size, tempStream, stride, bitmapProperties);
            }
        }
コード例 #4
0
        public static void WriteChat(D2D.WindowRenderTarget renderTarget, Starbase starbase, SharpDX.DirectWrite.Factory textFactory, TextFormat textFormat, float height, D2D.Brush brush)
        {
            renderTarget.Clear(new SharpDX.Mathematics.Interop.RawColor4(0f, 0f, 0f, 0f));

            lock (starbase.SyncMessages)
            {
                int number     = starbase.Messages.Count;
                int offset     = 0;
                int showNumber = number - 10 < 0 ? 0 : number - 10;
                int maxNumber  = number - showNumber < 10 ? number - showNumber : 10;

                if (number > 0)
                {
                    foreach (string message in starbase.Messages.GetRange(showNumber, maxNumber))
                    {
                        using (SharpDX.DirectWrite.TextLayout layout = new SharpDX.DirectWrite.TextLayout(textFactory, message, textFormat, 500, 500))
                            renderTarget.DrawTextLayout(new SharpDX.Mathematics.Interop.RawVector2()
                            {
                                X = 10, Y = height - 110 + offset
                            }, layout, brush, D2D.DrawTextOptions.Clip);

                        offset += 10;
                    }
                }
            }
        }
コード例 #5
0
        void CreateRenderTarget()
        {
            var renderProp = new sd.RenderTargetProperties
            {
                DpiX     = 0,
                DpiY     = 0,
                MinLevel = sd.FeatureLevel.Level_DEFAULT,
                Type     = sd.RenderTargetType.Default,
                Usage    = sd.RenderTargetUsage.None
            };

            if (drawable != null)
            {
                renderProp.PixelFormat = new sd.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, sd.AlphaMode.Premultiplied);
                var winProp = new sd.HwndRenderTargetProperties
                {
                    Hwnd           = drawable.Control.Handle,
                    PixelSize      = drawable.ClientSize.ToDx(),
                    PresentOptions = sd.PresentOptions.Immediately
                };

                Control = new sd.WindowRenderTarget(SDFactory.D2D1Factory, renderProp, winProp);
            }
            else if (image != null)
            {
                var imageHandler = image.Handler as BitmapHandler;
                renderProp.PixelFormat = new sd.PixelFormat(SharpDX.DXGI.Format.Unknown, sd.AlphaMode.Unknown);
                Control = new sd.WicRenderTarget(SDFactory.D2D1Factory, imageHandler.Control, renderProp);
            }
        }
コード例 #6
0
ファイル: MapView.cs プロジェクト: MarcusWichelmann/StepBot
		private void UnloadGraphics()
		{
			windowRenderTarget?.Dispose();
			factory?.Dispose();

			windowRenderTarget = null;
			factory = null;
		}
コード例 #7
0
        protected override void OnDraw(SharpDX.Direct2D1.WindowRenderTarget device)
        {
            if (once)
            {
                System.Drawing.Bitmap bmp = (System.Drawing.Bitmap)Resources.ResourceManager.GetObject("ranks");
                try
                {
                    this.ranksBmp = SDXBitmapFromSysBitmap(device, bmp);
                    once          = false;
                }
                catch { }
            }
            csgo = (CSGOImplementation)Program.GameImplementation;
            Player currentPlayer = csgo.GetCurrentPlayer();

            if (csgo.SignOnState < SignOnState.SIGNONSTATE_PRESPAWN || csgo.SignOnState > SignOnState.SIGNONSTATE_FULL)
            {
                return;
            }
            if (csgo.Players == null)
            {
                return;
            }
            if (csgo.Players.Length == 0)
            {
                return;
            }
            if (currentPlayer == null)
            {
                return;
            }
            if (csgo.GetValue <YesNo>("espEnabled") == YesNo.No)
            {
                return;
            }

            try { DrawWorld(device, csgo); }
            catch { }

            try
            {
                foreach (Player player in csgo.Players)
                {
                    DrawPlayer(device, currentPlayer, player);
                }
                foreach (Entity entity in csgo.Entities)
                {
                    DrawEntity(device, currentPlayer, entity);
                }
                for (int i = csgo.Damages.Count - 1; i >= 0; i--)
                {
                    DrawDamage(device, currentPlayer, csgo.Damages[i]);
                }
            }
            catch { }
            //DrawPunchAngles(device, csgo);
        }
コード例 #8
0
 /// <summary>
 /// Recreates the render target, if necessary, by calling SetRenderTarget</summary>
 protected override void RecreateRenderTarget()
 {
     var curRT = (WindowRenderTarget)D2dRenderTarget;
     Matrix3x2F xform = Transform;
     var hwnProps = new HwndRenderTargetProperties();
     hwnProps.Hwnd = Hwnd;
     hwnProps.PixelSize = curRT.PixelSize;
     hwnProps.PresentOptions = PresentOptions.Immediately;
     RenderTarget rt = new WindowRenderTarget(D2dFactory.NativeFactory, D2dFactory.RenderTargetProperties, hwnProps);            
     SetRenderTarget(rt);
     Transform = xform;           
 }
コード例 #9
0
ファイル: Renderer.cs プロジェクト: horttanainen/React.NET
        public Renderer(IntPtr hwnd, Bounds b)
        {
            this.hwnd          = hwnd;
            this.currentBounds = b;
            d2dFactory         = new SharpDX.Direct2D1.Factory(FactoryType.SingleThreaded);
            fontFactory        = new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared);

            var properties = new RenderTargetProperties(new PixelFormat(Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied));

            d2dTarget = new SharpDX.Direct2D1.WindowRenderTarget(d2dFactory, properties, new HwndRenderTargetProperties
            {
                Hwnd           = hwnd,
                PixelSize      = new Size2(currentBounds.Width, currentBounds.Height),
                PresentOptions = PresentOptions.Immediately
            });
        }
コード例 #10
0
        private void OnFormLoad(object sender, EventArgs e)
        {
            if (_osuModel != null)
            {
                LogUtil.LogInfo("Form loads normally.");
            }
            else
            {
                LogUtil.LogError("Form loads without real-time instance.");
                return;
            }

            Paint += OnPaint;
            // Initial settings
            var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied);
            var winProp     = new D2D.HwndRenderTargetProperties
            {
                Hwnd           = Handle,
                PixelSize      = new DX.Size2(ClientSize.Width, ClientSize.Height),
                PresentOptions = _useVsync ? D2D.PresentOptions.None : D2D.PresentOptions.Immediately
            };
            var renderProp = new D2D.RenderTargetProperties(D2D.RenderTargetType.Hardware, pixelFormat, 96, 96,
                                                            D2D.RenderTargetUsage.ForceBitmapRemoting, D2D.FeatureLevel.Level_DEFAULT);

            RenderTarget = new D2D.WindowRenderTarget(Factory, renderProp, winProp)
            {
                AntialiasMode     = D2D.AntialiasMode.PerPrimitive,
                TextAntialiasMode = D2D.TextAntialiasMode.Grayscale,
                Transform         = new Mathe.RawMatrix3x2(1, 0, 0, 1, 0, 0)
            };

            LayerList = new List <DxLayer>
            {
                new BgDxLayer(RenderTarget, _obj, _osuModel),
                new SongInfoDxLayer(RenderTarget, _obj, _osuModel),
                new FpsDxLayer(RenderTarget, _obj, _osuModel),
                //new TestLayer(RenderTarget, _obj, _osuModel),
            };

            _renderTask = new Task[LayerList.Count];

            // Avoid artifacts
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);

            Text = "Osu!Live Player (DX)";
            LogUtil.LogInfo("Form loaded.");
        }
コード例 #11
0
        protected override void Initialize(DemoConfiguration demoConfiguration)
        {
            Factory2D = new SharpDX.Direct2D1.Factory();
            FactoryDWrite = new SharpDX.DirectWrite.Factory();

            HwndRenderTargetProperties properties = new HwndRenderTargetProperties();
            properties.Hwnd = DisplayHandle;
            properties.PixelSize = new SharpDX.DrawingSize(demoConfiguration.Width, demoConfiguration.Height);
            properties.PresentOptions = PresentOptions.None;

            RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)), properties);

            RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive;


            SceneColorBrush = new SolidColorBrush(RenderTarget2D, Color.White);
        }
コード例 #12
0
        /// <summary>
        /// Initializes a Direct2D device used to draw to the screen. You MUST set the Direct2D Drawing Delegate to your own method, see the wiki for sample.
        /// </summary>
        public void Initialize_DirectX()
        {
            // Init DirectX
            // This initializes the DirectX device. It needs to be done once.

            // Wait for Heroes Window to spawn, when spawned, set the DirectX properties.
            Thread Get_Heroes_Window_Thread = new Thread
                                              (
                () =>
            {
                try
                {
                    // Wait for Sonic Heroes Window to spawn.
                    while (overlayWinForm.Window_Setup_Complete == false)
                    {
                        Thread.Sleep(8);
                    }
                    // Create the D2D1 Factory
                    SharpDX.Direct2D1.Factory Direct2D_Factory = new SharpDX.Direct2D1.Factory(SharpDX.Direct2D1.FactoryType.SingleThreaded);

                    // Set the render properties!
                    SharpDX.Direct2D1.HwndRenderTargetProperties Direct2D_Render_Target_Properties = new HwndRenderTargetProperties();
                    Direct2D_Render_Target_Properties.Hwnd           = overlayWinForm.Handle;
                    Direct2D_Render_Target_Properties.PixelSize      = new SharpDX.Size2(overlayWinForm.Width, overlayWinForm.Height);
                    Direct2D_Render_Target_Properties.PresentOptions = PresentOptions.None;

                    direct2DWindowTarget = new SharpDX.Direct2D1.WindowRenderTarget
                                           (
                        Direct2D_Factory,
                        new RenderTargetProperties(new PixelFormat(Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied)),
                        Direct2D_Render_Target_Properties
                                           );

                    DirectX_Clear_Screen();     // Clear the residue graphics left from the Windows form which was made transparent and clickthrough.
                    Ready_To_Render = true;
                }
                catch
                {
                }
            }
                                              );

            Get_Heroes_Window_Thread.Start();
        }
コード例 #13
0
ファイル: RenderForm.cs プロジェクト: Milkitic/Bingo
        private void LoadTarget(object sender, EventArgs e)
        {
            // Initial settings
            var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied);
            var winProp     = new D2D.HwndRenderTargetProperties
            {
                Hwnd           = Handle,
                PixelSize      = new DX.Size2(ClientSize.Width, ClientSize.Height),
                PresentOptions = Program.MainSettings.LimitFps ? D2D.PresentOptions.None : D2D.PresentOptions.Immediately
            };
            var renderProp = new D2D.RenderTargetProperties(D2D.RenderTargetType.Default, pixelFormat, 96, 96,
                                                            D2D.RenderTargetUsage.None, D2D.FeatureLevel.Level_DEFAULT);

            RenderTarget = new D2D.WindowRenderTarget(Factory, renderProp, winProp)
            {
                AntialiasMode     = D2D.AntialiasMode.PerPrimitive,
                TextAntialiasMode = D2D.TextAntialiasMode.Grayscale,
                Transform         = new Mathe.RawMatrix3x2 {
                    M11 = 1f, M12 = 0f, M21 = 0f, M22 = 1f, M31 = 0, M32 = 0
                }
            };

            // Create colors
            _colorBack = new Mathe.RawColor4(0, 0, 0, 1);

            LayerList = new Dictionary <string, ILayer>();
            LayerList.Add("back", new Background());
            if (Program.MainSettings.UseParticle)
            {
                LayerList.Add("particle", new Particle(500));
            }
            LayerList.Add("chess", new Chessboard());

            // Create brushes
            _whiteBrush = new D2D.SolidColorBrush(RenderTarget, new Mathe.RawColor4(1, 1, 1, 1));

            // Create text formats
            _textFormat = new DW.TextFormat(FactoryWrite, "Microsoft YaHei", 12);

            // Avoid artifacts
            SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
        }
コード例 #14
0
ファイル: FlowSink.cs プロジェクト: zyQmma/SharpDX-Samples
        public void DrawGlyphRuns(SharpDX.Direct2D1.WindowRenderTarget renderTarget, SharpDX.Direct2D1.Brush brush)
        {
            // Just iterate through all the saved glyph runs
            // and have DWrite to draw each one.

            for (int i = 0; i < glyphRuns_.Count; i++)
            {
                CustomGlyphRun customGlyphRun = glyphRuns_[i];
                if (customGlyphRun.glyphCount == 0)
                {
                    continue;
                }

                GlyphRun glyphRun = customGlyphRun.Convert(glyphIndices_, glyphAdvances_, glyphOffsets_);
                if (glyphRun != null)
                {
                    renderTarget.DrawGlyphRun(new Vector2(customGlyphRun.x, customGlyphRun.y), glyphRun, brush, MeasuringMode.Natural);
                }
            }
        }
コード例 #15
0
        void CreateRenderTarget()
        {
#if WINFORMS
            if (drawable != null)
            {
                var renderProp = CreateRenderProperties();
                renderProp.PixelFormat = new sd.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, sd.AlphaMode.Premultiplied);
                var winProp = new sd.HwndRenderTargetProperties
                {
                    Hwnd           = drawable.Control.Handle,
                    PixelSize      = drawable.ClientSize.ToDx(),
                    PresentOptions = sd.PresentOptions.Immediately
                };

                Control = new sd.WindowRenderTarget(SDFactory.D2D1Factory, renderProp, winProp);
                return;
            }
#endif
            CreateWicTarget();             // this is executed in winforms if not created from a drawable, and always in Xaml.
        }
コード例 #16
0
ファイル: HwndRenderBase.cs プロジェクト: lywbh/Osu-Player
        public HwndRenderBase(Control control)
        {
            var hwndProp = new D2D.HwndRenderTargetProperties
            {
                Hwnd           = control.Handle,
                PixelSize      = new DX.Size2(control.ClientSize.Width, control.ClientSize.Height),
                PresentOptions = Vsync ? D2D.PresentOptions.None : D2D.PresentOptions.Immediately
            };

            var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied);
            var renderProp  = new D2D.RenderTargetProperties(D2D.RenderTargetType.Hardware, pixelFormat, 96, 96,
                                                             D2D.RenderTargetUsage.ForceBitmapRemoting, D2D.FeatureLevel.Level_DEFAULT);

            RenderTarget = new D2D.WindowRenderTarget(Factory, renderProp, hwndProp)
            {
                AntialiasMode     = D2D.AntialiasMode.Aliased,
                TextAntialiasMode = D2D.TextAntialiasMode.Default,
                Transform         = new Mathe.RawMatrix3x2(1, 0, 0, 1, 0, 0)
            };
        }
コード例 #17
0
ファイル: MapView.cs プロジェクト: MarcusWichelmann/StepBot
		private void InitializeGraphics()
		{
			factory = new Factory(FactoryType.SingleThreaded, DebugLevel.None);

			renderTargetProperties = new RenderTargetProperties(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied));

			hwndRenderTargetProperties = new HwndRenderTargetProperties();
			hwndRenderTargetProperties.Hwnd = this.Handle;
			hwndRenderTargetProperties.PixelSize = new SharpDX.Size2(Width, Height);
			hwndRenderTargetProperties.PresentOptions = PresentOptions.None;

			windowRenderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties);

			backgroundColor = new RawColor4(BackColor.R, BackColor.G, BackColor.B, BackColor.A);

			borderColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0.5f, 0.5f, 0.5f, 1));
			wayColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0, 0, 1, 0.3f));
			currentPositionColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0, 0, 1, 1));

			graphicsInitialized = true;
		}
コード例 #18
0
        private void CreateTarget(int width, int height, System.IntPtr hwnd)
        {
            RenderTarget?.Dispose();
            var hwndProp = new D2D.HwndRenderTargetProperties
            {
                Hwnd           = hwnd,
                PixelSize      = new DX.Size2(width, height),
                PresentOptions = Vsync ? D2D.PresentOptions.None : D2D.PresentOptions.Immediately
            };

            var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied);
            var renderProp  = new D2D.RenderTargetProperties(D2D.RenderTargetType.Hardware, pixelFormat, 96, 96,
                                                             D2D.RenderTargetUsage.ForceBitmapRemoting, D2D.FeatureLevel.Level_DEFAULT);

            RenderTarget = new D2D.WindowRenderTarget(Factory, renderProp, hwndProp)
            {
                AntialiasMode     = D2D.AntialiasMode.Aliased,
                TextAntialiasMode = D2D.TextAntialiasMode.Default,
                Transform         = new Mathe.RawMatrix3x2(1, 0, 0, 1, 0, 0)
            };
        }
コード例 #19
0
        private void LoadTarget(object sender, EventArgs e)
        {
            var pixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied);

            var winProp = new D2D.HwndRenderTargetProperties
            {
                Hwnd           = this.Handle,
                PixelSize      = new DX.Size2(this.ClientSize.Width, this.ClientSize.Height),
                PresentOptions = D2D.PresentOptions.Immediately
            };

            var renderProp = new D2D.RenderTargetProperties(D2D.RenderTargetType.Default, pixelFormat,
                                                            96, 96, D2D.RenderTargetUsage.None, D2D.FeatureLevel.Level_DEFAULT);

            RenderTarget = new D2D.WindowRenderTarget(Factory, renderProp, winProp)
            {
                AntialiasMode     = D2D.AntialiasMode.PerPrimitive,
                TextAntialiasMode = D2D.TextAntialiasMode.Grayscale,
                Transform         = new Mathe.RawMatrix3x2
                {
                    M11 = 1,
                    M12 = 0,
                    M21 = 0,
                    M22 = 1,
                    M31 = 0,
                    M32 = 0
                }
            };

            // Create colors
            colorBack = new Mathe.RawColor4(0, 0, 0, 1);

            // Initialize layers
            layerClock    = new Layer.Clock(this.ClientSize);
            layerParticle = new Layer.Particles(500, 200);
            layerBack     = new Layer.Background();

            // Avoid artifacts
            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
        }
コード例 #20
0
        static bool InitialiseD2D()
        {
            d2dFactory   = new SharpDX.Direct2D1.Factory(SharpDX.Direct2D1.FactoryType.SingleThreaded);
            writeFactory = new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared);

            GetClientRect(OverlayWindow, out OverlayRect);

            var renderProps = new RenderTargetProperties
            {
                Type        = RenderTargetType.Default,
                PixelFormat = new PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied),
                Usage       = RenderTargetUsage.None
            };

            var hwndProps = new HwndRenderTargetProperties()
            {
                Hwnd           = OverlayWindow,
                PixelSize      = new Size2(OverlayRect.Width, OverlayRect.Height),
                PresentOptions = PresentOptions.Immediately //Replace for None
            };

            target = new WindowRenderTarget(d2dFactory, renderProps, hwndProps)
            {
                AntialiasMode = AntialiasMode.PerPrimitive
            };

            format = new TextFormat(writeFactory, "Segoe Ui Light", 16);

            brushes = new Dictionary <string, SolidColorBrush>()
            {
                { "red", new SolidColorBrush(target, new RawColor4(1, 0, 0, 1)) },
                { "green", new SolidColorBrush(target, new RawColor4(0, 1, 0, 1)) },
                { "blue", new SolidColorBrush(target, new RawColor4(0, 0, 1, 1)) },
                { "black", new SolidColorBrush(target, new RawColor4(0, 0, 0, 1)) },
                { "white", new SolidColorBrush(target, new RawColor4(1, 1, 1, 1)) }
            };

            return(target != null);
        }
コード例 #21
0
        protected virtual void InitializeDirectXResources()
        {
            var clientSize = ClientSize;

            foreach (var driverType in DriverTypes)
            {
                try
                {
                    D3DDevice = new D3D11.Device(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, FeatureLevels);
                    break;
                }
                catch (Exception e)
                {
                    Logger.Warn("InitializeDirectXResources - device not supported", e, "deviceType", driverType);
                }
            }

            if (D3DDevice == null)
            {
                throw new NotSupportedException("no supported driver types");
            }

            D2DFactory = new D2D1.Factory();

            RenderTarget = new D2D1.WindowRenderTarget(D2DFactory,
                                                       new D2D1.RenderTargetProperties(new D2D1.PixelFormat(Format.Unknown, D2D1.AlphaMode.Ignore)),
                                                       new D2D1.HwndRenderTargetProperties
            {
                Hwnd           = Handle,
                PixelSize      = new Size2(clientSize.Width, clientSize.Height),
                PresentOptions = D2D1.PresentOptions.Immediately
            });

            SolidColorBrush = new D2D1.SolidColorBrush(RenderTarget, Color.White);

            DwFactory = new DW.Factory(DW.FactoryType.Shared);
        }
コード例 #22
0
        public Direct2DRenderer(IntPtr hwnd, bool limitFps)
        {
            _factory = new Factory();

            _fontFactory = new FontFactory();

            RECT bounds;//immer 1920x1080. resizing muss durch die Overlay klasse geregelt sein
            NativeMethods.GetWindowRect(hwnd, out bounds);

            var targetProperties = new HwndRenderTargetProperties
            {
                Hwnd = hwnd,
                PixelSize = new Size2(bounds.Right - bounds.Left, bounds.Bottom - bounds.Top),
                PresentOptions = limitFps ? PresentOptions.None : PresentOptions.Immediately //Immediatly -> Zeichnet sofort ohne auf 60fps zu locken. None lockt auf 60fps
            };

            var prop = new RenderTargetProperties(RenderTargetType.Hardware, new PixelFormat(Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied), 0, 0, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT);

            _device = new WindowRenderTarget(_factory, prop, targetProperties)
            {
                TextAntialiasMode = TextAntialiasMode.Cleartype,
                AntialiasMode = AntialiasMode.PerPrimitive
            };
        }
コード例 #23
0
        private void initialize_Tick(object sender, EventArgs e)
        {
            initialize.Enabled = false;

            factory      = new D2D.Factory(D2D.FactoryType.SingleThreaded);
            renderTarget = new D2D.WindowRenderTarget(factory,
                                                      new D2D.RenderTargetProperties(), new D2D.HwndRenderTargetProperties()
            {
                Hwnd           = Handle,
                PixelSize      = new SharpDX.Size2(ClientRectangle.Width, ClientRectangle.Height),
                PresentOptions = D2D.PresentOptions.Immediately
            }
                                                      );

            brushes = new UIBrushes(renderTarget);

            textFactory = new Factory();
            textFormat  = new SharpDX.DirectWrite.TextFormat(textFactory, "Segoe UI Light", 10f);

            width  = ClientRectangle.Width;
            height = ClientRectangle.Height;

            refresh.Enabled = true;
        }
コード例 #24
0
ファイル: Game.cs プロジェクト: fcym97/FadeGE
        /// <summary>
        /// 初始化绘图有关组件
        /// </summary>
        /// <param name="width">游戏窗口宽度</param>
        /// <param name="height">游戏窗口高度</param>
        /// <param name="title">游戏窗口标题</param>
        private void InitRenderComponent(int width, int height, string title)
        {
            WindowSize = new Size2(width, height);

            var factory = new Factory(FactoryType.SingleThreaded);

            var hwndRenderTargetProperties = new HwndRenderTargetProperties {
                Hwnd = Form.Handle,
                PixelSize = new Size2(Form.Width, Form.Height),
                PresentOptions = PresentOptions.RetainContents
            };

            var pixelFormat = new PixelFormat(Format.B8G8R8A8_UNorm, AlphaMode.Ignore);
            var renderTargetProperties = new RenderTargetProperties(
                RenderTargetType.Hardware, pixelFormat, 0, 0, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT);

            renderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties);
        }
コード例 #25
0
ファイル: Form1.cs プロジェクト: shrknt35/SharpDX_Demo
        private void Form1_Load(object sender, EventArgs e)
        {
            //Init Direct Draw
            //Set Rendering properties
            RenderTargetProperties renderProp = new RenderTargetProperties()
            {
                DpiX = 0,
                DpiY = 0,
                MinLevel = FeatureLevel.Level_10,
                PixelFormat = new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied),
                Type = RenderTargetType.Hardware,
                Usage = RenderTargetUsage.None
            };

            //set hwnd target properties (permit to attach Direct2D to window)
            HwndRenderTargetProperties winProp = new HwndRenderTargetProperties()
            {
                Hwnd = this.Handle,
                PixelSize = new DrawingSize(this.ClientSize.Width, this.ClientSize.Height),
                PresentOptions = PresentOptions.Immediately
            };

            //target creation
            target = new WindowRenderTarget(factory, renderProp, winProp);

            //create red and white brushes
            redBrush = new SharpDX.Direct2D1.SolidColorBrush(target, SharpDX.Color.Red);
            whiteBrush = new SharpDX.Direct2D1.SolidColorBrush(target, SharpDX.Color.White);

            //create a linear gradient brush
            var grad = new LinearGradientBrushProperties()
            {
                StartPoint = new DrawingPointF(ClientSize.Width / 2, ClientSize.Height / 2),
                EndPoint = new DrawingPointF(ClientSize.Width, ClientSize.Height)
            };

            var stopCollection = new GradientStopCollection(target, new GradientStop[]
            {
                new GradientStop(){Color=SharpDX.Color.Azure ,Position=0F},
                new GradientStop(){Color=SharpDX.Color.Yellow,Position=0.2F},
                new GradientStop(){Color=SharpDX.Color.Green,Position=0.4F},
                new GradientStop(){Color=SharpDX.Color.Red,Position=1F},
            }, ExtendMode.Mirror);

            gradient = new SharpDX.Direct2D1.LinearGradientBrush(target, grad, stopCollection);

            //create textformat
            textFormat = new SharpDX.DirectWrite.TextFormat(factoryWrite, "Arial", 36);

            //avoid artifacts
            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.Opaque, true);
        }
コード例 #26
0
        private void DrawWorld(WindowRenderTarget device, CSGOImplementation csgo)
        {
            if (csgo.CurrentMap == null)
                return;
            if (csgo.GetValue<YesNo>("wireframeEnabled") == YesNo.No)
                return;

            BSP map = csgo.CurrentMap;
            Color color = new Color((int)csgo.GetValue<float>("wireframeColorR"), (int)csgo.GetValue<float>("wireframeColorG"), (int)csgo.GetValue<float>("wireframeColorB"), (int)csgo.GetValue<float>("wireframeColorA"));
            float distanceMeters = csgo.GetValue<float>("wireframeDistance");
            float scale = 1f;
            bool drawOnlyMe = (csgo.GetValue<YesNo>("wireframeDrawAroundMe") == YesNo.Yes);
            Target drawTarget = csgo.GetValue<Target>("wireframeDrawTarget");

            for (int f = 0; f < map.OriginalFaces.Length; f++)
            {
                Face face = map.OriginalFaces[f];
                if (map.TextureInfo.Length > face.texinfo)
                {
                    if ((map.TextureInfo[face.texinfo] & SurfFlag.SURF_NODRAW) == SurfFlag.SURF_NODRAW)
                        continue;
                }
                for (int e = 0; e < face.numEdges; e++)
                {

                    float dist = 1f;
                    int surfedge = map.Surfedges[face.firstEdge + e];
                    ushort[] edge = map.Edges[Math.Abs(surfedge)];
                    Vector3 line3d1, line3d2;
                    if (surfedge > 0)
                    {
                        line3d1 = map.Vertices[edge[0]];
                        line3d2 = map.Vertices[edge[1]];
                    }
                    else
                    {
                        line3d1 = map.Vertices[edge[1]];
                        line3d2 = map.Vertices[edge[0]];
                    }

                    bool valid = false;
                    dist = Geometry.GetDistanceToPoint(line3d1, csgo.LocalPlayer.Vector3) * UNIT_TO_METERS;
                    //valid = true;
                    //if (dist > distanceMeters)
                    //    break;
                    if (!drawOnlyMe)
                    {
                        foreach (Player player in csgo.Players)
                        {
                            if (player == null)
                                continue;
                            if (!player.IsValid())
                                continue;
                            if (drawTarget != Target.Everyone)
                            {
                                if (drawTarget == Target.Allies && (player.InTeam != csgo.LocalPlayer.InTeam))
                                    continue;
                                if (drawTarget == Target.Enemies && (player.InTeam == csgo.LocalPlayer.InTeam))
                                    continue;
                            }
                            float tmpDist = Geometry.GetDistanceToPoint(line3d1, player.Vector3) * UNIT_TO_METERS;
                            if (
                                tmpDist < distanceMeters/* ||
                                Geometry.GetDistanceToPoint(line3d2, player.Vector3) * UNIT_TO_METERS < distanceMeters*/
                            )
                            {
                                valid = true;
                                if (tmpDist < dist)
                                    dist = tmpDist;
                            }
                        }
                        if (!valid)
                        {
                            break;
                        }
                    }
                    else
                    {
                        if (dist > distanceMeters)
                        {
                            break;
                        }
                    }
                    Vector2[] line = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, line3d1, line3d2);
                    if (line[0] == Vector2.Zero || line[1] == Vector2.Zero)
                        continue;
                    Color col = color;
                    if (csgo.GetValue<OnOff>("wireframeFading") == OnOff.On)
                    {
                        scale = 1f - 1f / distanceMeters * dist;
                        col = color;
                        col.A = (byte)(((float)col.A) * scale);
                    }
                    DrawLine(device, col, line[0].X, line[0].Y, line[1].X, line[1].Y, 1f);
                }

            }
        }
コード例 #27
0
        /// <summary>
        /// Inits the direct2D and direct write.
        /// </summary>
        private void InitDirect2DAndDirectWrite()
        {
            Factory2D = new SharpDX.Direct2D1.Factory();
            FactoryDWrite = new SharpDX.DirectWrite.Factory();

            var properties = new HwndRenderTargetProperties();
            properties.Hwnd = renderControl.Handle;
            properties.PixelSize = renderControl.ClientSize;
            properties.PresentOptions = PresentOptions.None;

            RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)), properties);
            RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive;
            RenderTarget2D.TextAntialiasMode = TextAntialiasMode.Cleartype;

            SceneColorBrush = new SolidColorBrush(RenderTarget2D, new Color4(1, 0, 0, 0));
        }
コード例 #28
0
ファイル: Program.cs プロジェクト: Kammikazy/SharpDX-Samples
        private static void CreateResources()
        {
            if (renderTarget != null) { renderTarget.Dispose(); }
            if (defaultBrush != null) { defaultBrush.Dispose(); }
            if (greenBrush != null) { greenBrush.Dispose(); }
            if (redBrush != null) { redBrush.Dispose(); }
            if (backgroundBrush != null) { backgroundBrush.Dispose(); }


            HwndRenderTargetProperties wtp = new HwndRenderTargetProperties();
            wtp.Hwnd = mainForm.Handle;
            wtp.PixelSize = new Size2(mainForm.ClientSize.Width, mainForm.ClientSize.Height);
            wtp.PresentOptions = PresentOptions.Immediately;
            renderTarget = new WindowRenderTarget(d2dFactory, new RenderTargetProperties(), wtp);

            defaultBrush = new SolidColorBrush(renderTarget, Color.White);
            greenBrush = new SolidColorBrush(renderTarget, Color.Green);
            redBrush = new SolidColorBrush(renderTarget, Color.Red);
            backgroundBrush = new SolidColorBrush(renderTarget, new Color4(0.3f, 0.3f, 0.3f, 0.5f));

            textRenderer.AssignResources(renderTarget, defaultBrush);

        }
コード例 #29
0
 protected abstract void OnDraw(WindowRenderTarget device);
コード例 #30
0
        private void DrawDamage(WindowRenderTarget device, Player currentPlayer, Damage damage)
        {
            if (damage == null)
                return;
            if (!damage.Alive)
            {
                csgo.Damages.Remove(damage);
            }

            if (!Geometry.PointSeesPoint(currentPlayer.Vector2, damage.Position2D, Player.FOV_DEGREE, currentPlayer.Yaw))
                return;
            damage.Update();
            Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, (damage.Position));
            float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, damage.Position);

            RectangleF size = Control.MeasureString(FactoryManager.GetFont("largeSegoe"), damage.Text);
            float max = Math.Max(size.Width, size.Height);
            float multiplier = damage.Multiplier;
            FillEllipse(device,
                lifeBarBackground * multiplier,
                point.X,
                point.Y,
                max,
                max,
                true);
            DrawText(device,
                colorT * multiplier,
                lifeBarBackground,
                point.X - size.Width / 2f,
                point.Y - size.Height / 2f,
                size.Width,
                size.Height,
                this.Theme.ShadowOffsetX,
                this.Theme.ShadowOffsetY,
                damage.Text,
                FactoryManager.GetFont("largeSegoe"));
        }
コード例 #31
0
        private void DrawEntity(WindowRenderTarget device, Player currentPlayer, Entity entity)
        {
            if (entity == null)
                return;
            if (entity.Address == currentPlayer.Address)
                return;
            if (!entity.IsValid())
                return;
            //if (!Geometry.PointSeesPoint(currentPlayer.Vector2, entity.Vector2, Player.FOV_DEGREE, currentPlayer.Yaw))
            //    return;

            Color brushColor = lifeBarForeground;
            Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, entity.Vector3);
            if (point == Vector2.Zero)
                return;
            Vector3 entPoint = entity.Vector3;
            float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, entity.Vector3);
            float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(entity);
            float boxBorder = 6400f / distance;
            float scale = 0.5f / distanceMeter;
            float rectX = point.X, rectY = point.Y, rectW = 24f * scale, rectH = 24f * scale;

            switch (entity.ClassID)
            {
                case Data.Enums.ClassID.Weapon:
                    brushColor = Color.Green;
                    if (csgo.GetValue<YesNo>("espDrawWeapons") == YesNo.No)
                        return;
                    if (entity.OwnerEntity != -1)
                        return;
                    break;
                case Data.Enums.ClassID.Hostage:
                    brushColor = Color.LemonChiffon;
                    return;
                case Data.Enums.ClassID.C4:
                    if (currentPlayer.Index == entity.OwnerEntity)
                        return;
                    brushColor = Color.DarkRed;
                    //if (entity.OwnerEntity > -1 && entity.OwnerEntity < csgo.Players.Length - 1)
                    //{
                    //    point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4);
                    //    rectX = point.X;
                    //    rectY = point.Y;
                    //    FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
                    //    entPoint = csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4;
                    //}
                    break;
                case Data.Enums.ClassID.PlantedC4:
                    brushColor = Color.DarkRed;
                    //FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
                    break;
                default:
                    return;
            }
            if (entity.ClassID == Data.Enums.ClassID.Chicken || entity.ClassID == Data.Enums.ClassID.Hostage)
            {
                //Paint bones
                //List<Vector3> allBones = new List<Vector3>();
                //if (distanceMeter < 20)
                //    allBones.AddRange(entity.Skeleton.Arms);
                //allBones.AddRange(entity.Skeleton.Legs);
                //allBones.AddRange(entity.Skeleton.Spine);
                //allBones.Add(entity.Skeleton.Neck);
                //for (int i = allBones.Count - 1; i >= 0; i--)
                //    if (allBones[i] == Vector3.Zero)
                //        allBones.RemoveAt(i);

                //Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
                //allBones.Clear();
                //allBones = null;

                //rectX = GetSmallestX(all);
                //rectW = GetBiggestX(all);
                //rectY = GetSmallestY(all);
                //rectH = GetBiggestY(all);
                //rectW -= rectX;
                //rectH -= rectY;
            }

            rectX -= boxBorder;
            rectY -= boxBorder;
            rectW += boxBorder * 2f;
            rectH += boxBorder * 2f;

            #region glow
            if (csgo.GetValue<YesNo>("espGlowEnabled") == YesNo.Yes)
            {
                if (csgo.GlowObjects != null)
                {
                    CSGOGameController controller = (CSGOGameController)Program.GameController;
                    int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)entity.Address);
                    if (idx != -1)
                    {
                        GlowObjectDefinition def = csgo.GlowObjects[idx];
                        def.a = 1f;// (float)(brushColor.A / 255f);
                        def.r = (float)(brushColor.R / 255f);
                        def.g = (float)(brushColor.G / 255f);
                        def.b = (float)(brushColor.B / 255f);
                        def.m_bRenderWhenOccluded = true;
                        def.m_bRenderWhenUnoccluded = true;
                        controller.MemoryUpdater.WriteGlowObject(def, idx);
                    }
                }
            }
            #endregion

            if (point != Vector2.Zero)
            {
                #region box
                if (csgo.GetValue<OnOff>("espDrawBox") == OnOff.On)
                {
                    //Draw box
                    DrawW2SBox(device,
                        brushColor,
                        entPoint - Vector3.UnitZ * 8,
                        16f,
                        16f,
                        entity.Yaw + 45f,
                        15f / distanceMeter);
                }
                #endregion

                #region distance
                if (csgo.GetValue<OnOff>("espDrawDistance") == OnOff.On)
                {
                    ////Draw text
                    DrawText(device,
                        foreColor,
                        backColor,
                        rectX,
                        rectY + rectH,
                        100f,
                        20f,
                        1f,
                        1f,
                        Math.Round(distanceMeter, 0).ToString() + "m",
                        FactoryManager.GetFont("smallSegoe"));
                }
                #endregion
                string name = entity.Name;
                if (
                    entity.ClassID != Data.Enums.ClassID.Chicken &&
                    entity.ClassID != Data.Enums.ClassID.Hostage &&
                    entity.ClassID != Data.Enums.ClassID.CSPlayer &&
                    entity.ClassID != Data.Enums.ClassID.Weapon &&
                    entity.ClassID != Data.Enums.ClassID.C4 &&
                    entity.ClassID != Data.Enums.ClassID.PlantedC4)
                    name = String.Format("{0} (ID#{1})", name, entity.ClassID);
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX,
                    rectY - 20f,
                    100f,
                    20f,
                    1f,
                    1f,
                    name,
                    FactoryManager.GetFont("smallSegoe"));

            }
        }
コード例 #32
0
 internal D2dHwndGraphics(WindowRenderTarget renderTarget)
     : base(renderTarget)
 {
     
 }
コード例 #33
0
        private void DrawPlayer(WindowRenderTarget device, Player currentPlayer, Player player)
        {
            if (player == null)
                return;
            if (player.Index == currentPlayer.Index)
                return;
            if (!player.IsValid())
                return;
            if (csgo.GetValue<Target>("espDrawTarget") == Target.Enemies && player.InTeam == currentPlayer.InTeam)
                return;
            if (csgo.GetValue<Target>("espDrawTarget") == Target.Allies && player.InTeam != currentPlayer.InTeam)
                return;

            player.CheckYaw();

            Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, (player.Vector3));
            if (point == Vector2.Zero)
                return;
            float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, player.Vector3);
            float height = 36000f / distance;
            float width = 18100f / distance;
            Color colorPlayer = player.InTeam == Team.Terrorists ?
                (player.SeenBy(currentPlayer) ? colorTSpotted : colorT) :
                (player.SeenBy(currentPlayer) ? colorCTSpotted : colorCT);

            float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(player);
            float head = 3200f / distance;
            float boxBorder = 6400f / distance;
            bool highlighted = csgo.Highlighted[player.Index - 1];
            //Paint bones
            List<Vector3> allBones = new List<Vector3>();

            allBones.AddRange(player.Skeleton.Legs);
            allBones.AddRange(player.Skeleton.Spine);
            allBones.Add(player.Skeleton.HeadEnd);

            Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
            foreach (Vector2 vec in all)
                if (vec == Vector2.Zero)
                    return;
            Vector2[] arms = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Arms);
            Vector2[] legs = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Legs);
            Vector2[] spine = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Spine);
            allBones.Clear();
            allBones = null;

            float rectX = GetSmallestX(all) + 5, rectW = GetBiggestX(all) + 5, rectY = GetSmallestY(all) + 5, rectH = GetBiggestY(all) + 5;
            //rectW -= rectX;
            rectH -= rectY;
            rectW = rectH * 0.3f;
            rectX = point.X - rectW / 2f;
            #region glow
            if (csgo.GetValue<YesNo>("espGlowEnabled") == YesNo.Yes)
            {
                if (csgo.GlowObjects != null)
                {
                    CSGOGameController controller = (CSGOGameController)Program.GameController;
                    int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)player.Address);
                    if (idx != -1)
                    {
                        GlowObjectDefinition def = csgo.GlowObjects[idx];
                        def.a = (float)(colorPlayer.A / 255f);
                        def.r = (float)(colorPlayer.R / 255f);
                        def.g = (float)(colorPlayer.G / 255f);
                        def.b = (float)(colorPlayer.B / 255f);
                        def.m_bRenderWhenOccluded = true;
                        def.m_bRenderWhenUnoccluded = true;
                        def.m_bFullBloom = false;
                        if (csgo.GetValue<YesNo>("espGlowFadingEnabled") == YesNo.Yes)
                        {
                            float dist = currentPlayer.DistanceToOtherEntityInMetres(player);
                            float range = csgo.GetValue<float>("espGlowFadingDistance");
                            if (dist <= range)
                            {
                                def.a = 1f - 1f / range * dist;
                                controller.MemoryUpdater.WriteGlowObject(def, idx);
                            }
                        }
                        else
                        {
                            controller.MemoryUpdater.WriteGlowObject(def, idx);
                        }
                    }
                }
            }
            #endregion
            #region skeleton
            if (csgo.GetValue<OnOff>("espDrawSkeleton") == OnOff.On)
            {
                if (distanceMeter < 20)
                    DrawBones(device,
                        colorPlayer,
                        arms,
                        1.5f,
                        player.InTeam
                        );
                DrawBones(device,
                    colorPlayer,
                    legs,
                    1.5f,
                    player.InTeam
                    );
                DrawBones(device,
                    colorPlayer,
                    spine,
                    1.5f,
                    player.InTeam
                    );
            }
            if (player.Skeleton.AllBones != null)
            {
                for (int i = 0; i < player.Skeleton.AllBones.Length; i++)
                {
                    Vector2 boneHead = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.AllBones[i]);
                    DrawText(device,
                        foreColor,
                        backColor,
                        boneHead.X,
                        boneHead.Y,
                        100f,
                        20f,
                        1f,
                        1f,
                        i.ToString(),
                        FactoryManager.GetFont("largeSegoe"));
                }
            }
            #endregion
            #region lines
            if (csgo.GetValue<OnOff>("espDrawLines") == OnOff.On)
            {
                Color color = colorPlayer;
                if (!player.IsSpotted)
                {
                    color *= 0.5f;
                }
                else
                {
                    color *= (0.75f + 0.25f * GetColorMultiplier());
                }
                FillPolygon(device,
                    color,
                    new Vector2(csgo.ScreenSize.Width / 2f, csgo.ScreenSize.Height),
                    new Vector2(point.X - width / 2f, point.Y),
                    new Vector2(point.X + width / 2f, point.Y));
            }
            #endregion
            #region box
            //Draw box
            if (csgo.GetValue<OnOff>("espDrawBox") == OnOff.On)
            {
                this.DrawRectangle(device,
                    colorPlayer,
                    rectX,
                    rectY,
                    rectW,
                    rectH,
                    1f);
            }
            #endregion
            #region circle
            if (csgo.GetValue<OnOff>("espDrawCircle") == OnOff.On)
            {
                Vector3[] circPoints = Geometry.Create3DFlatCircle(
                    player.Vector3,
                    32f + (player.IsSpotted ? 16f * GetColorMultiplier() : 0f),
                    32);
                Vector2[] scrCircPoints = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, circPoints);
                DrawLines(device, colorPlayer, 15f / distanceMeter, scrCircPoints);
            }
            #endregion
            #region distance
            if (csgo.GetValue<OnOff>("espDrawDistance") == OnOff.On)
            {
                string distString = Math.Round(distanceMeter, 0).ToString() + "m";
                RectangleF distSize = Control.MeasureString(this.Font, distString);
                //Draw text
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX + rectW / 2f - distSize.Width / 2f,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    distString,
                    FactoryManager.GetFont("smallSegoe"));
            }
            #endregion
            #region highlight
            if (highlighted)
            {
                float size = (float)Math.Max(rectW + boxBorder, rectH + boxBorder) * 2f;
                Color color = (colorPlayer) * (0.5f + 0.5f * GetColorMultiplier());
                FillEllipse(
                    device,
                    color * 0.5f,
                    rectX + rectW / 2f,
                    rectY + rectH / 2f,
                    size,
                    size,
                    true);
                DrawEllipse(device,
                    color, //* (DateTime.Now.Millisecond % 1000f / 1000f),
                    rectX + rectW / 2f,
                    rectY + rectH / 2f,
                    size,
                    size,
                    true,
                    1.5f);
            }
            #endregion
            #region name
            if (csgo.GetValue<OnOff>("espDrawName") == OnOff.On)
            {
                ////Name
                //DrawText(device,
                //    foreColor,
                //    backColor,
                //    rectX + rectW,
                //    rectY - boxBorder,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    (player.IsDormant ? "[DORMANT] " : "") + player.Name,
                //    FactoryManager.GetFont("smallSegoe"));
                ////Info
                //string weaponInfo = "-";
                //if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
                //{
                //    if (csgo.Entities[player.WeaponIndex] != null)
                //        weaponInfo = csgo.Entities[player.WeaponIndex].Name;
                //}

                //string data = String.Format(
                //"Weapon: {0}",
                //    /*player.Health, player.Armor,*/ weaponInfo);

                //if (csgo.GetValue<OnOff>("espDrawDetails") == OnOff.On)
                //    data = String.Format("{0}\n" +
                //    "Balance: ${1}\n" +
                //    "Kills: {2}\n" +
                //    "Assists: {3}\n" +
                //    "Deaths: {4}\n" +
                //    "Score: {5}",
                //    data, player.Money, player.Kills, player.Assists, player.Deaths, player.Score);

                //DrawText(device,
                //    foreColor,
                //    backColor,
                //    rectX + rectW,
                //    rectY - boxBorder + 16f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    data,
                //    FactoryManager.GetFont("tinySegoe"));
                string weaponInfo = "-";
                if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
                {
                    if (csgo.Entities[player.WeaponIndex] != null)
                        weaponInfo = csgo.Entities[player.WeaponIndex].Name;
                }
                string str = string.Format("{0}\n[{1}]", player.Name, weaponInfo);
                RectangleF size = Control.MeasureString(this.Font, str);
                //Name
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX + rectW / 2f - size.Width / 2f,
                    rectY - 40,
                    100f,
                    20f,
                    2f,
                    2f,
                    str,
                    FactoryManager.GetFont("smallSegoe"));
            }
            #endregion
            #region health
            if (csgo.GetValue<OnOff>("espDrawHealth") == OnOff.On)
            {
                ////HP
                //FillRectangle(device,
                //        lifeBarBackground,
                //        rectX,
                //        rectY - lifeBarHeight * 3f,
                //        width, //rectW,
                //        lifeBarHeight /*10f*/);
                //FillRectangle(device,
                //        lifeBarForeground,
                //        rectX,
                //        rectY - lifeBarHeight * 3f,
                //    /*rectW*/ width / 100f * player.Health,
                //        lifeBarHeight /*10f*/);
                //DrawText(device,
                //    lifeBarForeground,
                //    backColor,
                //    rectX + width,
                //    rectY - lifeBarHeight * 3f - 2f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    player.Health.ToString(),
                //    FactoryManager.GetFont("miniSegoe"));
                ////Armor
                //FillRectangle(device,
                //        lifeBarBackground,
                //        rectX,
                //        rectY - lifeBarHeight * 2f,
                //        width, //rectW,
                //        lifeBarHeight /*10f*/);
                //FillRectangle(device,
                //        viewColorOutline,
                //        rectX,
                //        rectY - lifeBarHeight * 2f,
                //    /*rectW*/ width / 100f * player.Armor,
                //        lifeBarHeight /*10f*/);
                //DrawText(device,
                //    viewColorOutline,
                //    backColor,
                //    rectX + width,
                //    rectY - lifeBarHeight * 2f - 2f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    player.Armor.ToString(),
                //    FactoryManager.GetFont("miniSegoe"));
                //HP
                FillRectangle(device,
                        lifeBarBackground,
                        rectX - lifeBarWidth,
                        rectY,
                        lifeBarWidth, //rectW,
                        rectH /*10f*/);
                FillRectangle(device,
                        lifeBarForeground,
                        rectX - lifeBarWidth,
                        rectY,
                        lifeBarWidth,
                        rectH / 100f * player.Health /*10f*/);
                DrawText(device,
                    lifeBarForeground,
                    backColor,
                    rectX - lifeBarWidth,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    player.Health.ToString(),
                    FactoryManager.GetFont("miniSegoe"));
                //Armor
                FillRectangle(device,
                        lifeBarBackground,
                        rectX + rectW,
                        rectY,
                        lifeBarWidth, //rectW,
                        rectH /*10f*/);
                FillRectangle(device,
                        viewColorOutline,
                        rectX + rectW,
                        rectY,
                        lifeBarWidth,
                        rectH / 100f * player.Armor /*10f*/);
                DrawText(device,
                    viewColorOutline,
                    backColor,
                    rectX + rectW,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    player.Armor.ToString(),
                    FactoryManager.GetFont("miniSegoe"));
            }
            #endregion
            #region rank
            if (player.Rank > 0)
            {
                //Scaling
                float boxWidth = rectW, boxHeight = rectW * aspect;
                /*
                 * Args:
                 * 1 actual bitmap
                 * 2 destination-rectangle
                 * 3 opacity
                 * 4 interpolation mode
                 * 5 source-rectangle - easy access using rank as index
                 */
                if (ranksBmp != null)
                {
                    device.DrawBitmap(
                    ranksBmp,
                    new RectangleF(point.X - boxWidth / 2f, point.Y + 20f, boxWidth, boxHeight),
                    0.7f,
                    BitmapInterpolationMode.Linear,
                    new RectangleF(0f, 80f * (player.Rank - 1), 200f, 80f));
                    if (boxWidth > 50f)
                        DrawText(device, foreColor, point.X - boxWidth / 2f, point.Y + 20f + boxHeight + 4f, 200f, 100f, string.Format("MM-wins: {0}", player.Wins.ToString()), this.Font);
                }
            }
            #endregion
        }
コード例 #34
0
ファイル: D2DView.cs プロジェクト: filipkunc/GLGraphics
        void InitD2D()
        {
            _factoryD2D = new SharpDX.Direct2D1.Factory();
            _factoryDWrite = new SharpDX.DirectWrite.Factory();

            HwndRenderTargetProperties properties = new HwndRenderTargetProperties();
            properties.Hwnd = this.Handle;
            properties.PixelSize = new SharpDX.Size2(this.Width, this.Height);
            properties.PresentOptions = PresentOptions.Immediately;

            _renderTarget = new WindowRenderTarget(_factoryD2D,
                new RenderTargetProperties(_renderTargetType,
                    new PixelFormat(Format.Unknown, AlphaMode.Premultiplied), 96.0f, 96.0f,
                    RenderTargetUsage.GdiCompatible, FeatureLevel.Level_DEFAULT), properties);
        }
コード例 #35
0
 private void DrawPunchAngles(WindowRenderTarget device, CSGOImplementation csgo)
 {
     DrawAngle(device, 700f, 300f, csgo.LocalPlayer.PunchVector.X, "Pitch"); //Y
     DrawAngle(device, 800f, 300f, csgo.LocalPlayer.PunchVector.Y, "Yaw");   //X
     DrawAngle(device, 900f, 300f, csgo.LocalPlayer.PunchVector.Z, "Roll");
 }
コード例 #36
0
        public virtual void InitDevice()
        {
            FactoryManager.Init();
            this.TopMost = true;

            renderProperties = new HwndRenderTargetProperties()
            {
                Hwnd = this.Handle,
                PixelSize = new Size2(this.Width, this.Height),
                PresentOptions = PresentOptions.None
            };
            device = new WindowRenderTarget(FactoryManager.Factory, new RenderTargetProperties(new PixelFormat(Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied)), renderProperties);
            device.TextAntialiasMode = TextAntialiasMode.Cleartype;

            this.OnInitDevice();

        }
コード例 #37
0
ファイル: CustomLayoutForm.cs プロジェクト: numo16/SharpDX
        /// <summary>
        /// Inits the direct2D and direct write.
        /// </summary>
        private void InitDirect2DAndDirectWrite()
        {
            Factory2D = new SharpDX.Direct2D1.Factory();
            FactoryDWrite = new SharpDX.DirectWrite.Factory();

            var properties = new HwndRenderTargetProperties { Hwnd = panel1.Handle, PixelSize = new Size2(panel1.ClientSize.Width, panel1.ClientSize.Height), PresentOptions = PresentOptions.None };

            RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), properties)
            {
                AntialiasMode = AntialiasMode.PerPrimitive,
                TextAntialiasMode = TextAntialiasMode.Cleartype
            };

            brush = new SolidColorBrush(RenderTarget2D, Color.Black);
        }
コード例 #38
0
        protected void Initialize()
        {
            // Load all of the factories
            Factories.LoadFactories();

            // Setup the graphics
            Console.WriteLine("Setup Graphics");

            var hwndprop = new HwndRenderTargetProperties();
            hwndprop.Hwnd = Handle;
            hwndprop.PixelSize = new Size2(Constants.Width, Constants.Height);
            hwndprop.PresentOptions = PresentOptions.Immediately;

            var rendprop = new RenderTargetProperties();
            rendprop.PixelFormat = new PixelFormat(DXGI.Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied);
            rendprop.Type = RenderTargetType.Hardware;

            SetClientSizeCore(Constants.Width, Constants.Height);
            RenderTarget2D = new WindowRenderTarget(Factories.Factory2D, rendprop, hwndprop);

            // Tick timer
            Console.WriteLine("Setup Timer");
            stopwatch = new Stopwatch();
            stopwatch.Start();
            physicsDelayTicks = Stopwatch.Frequency / updatesPerSecond;
            ticksToMilliFactor = 1.0 / (Stopwatch.Frequency / 1000.0);
            ticksToPhysicsStepPercentFactor = 1.0 / physicsDelayTicks;
            lastPhysicsStepTicks = 0.0;

            // Load all assets and resources
            Constants.Load();

            // Setup the main menu
            Console.WriteLine("Setup Menu");
            GameController.LoadInitialLevel(new LevelMenu());

            // Start the loop
            MainLoop();
        }
コード例 #39
0
        /// <summary>
        /// Inits the direct2D and direct write.
        /// </summary>
        private void InitDirect2DAndDirectWrite()
        {
            Factory2D = new SharpDX.Direct2D1.Factory();
            FactoryDWrite = new SharpDX.DirectWrite.Factory();

            var properties = new HwndRenderTargetProperties();
            properties.Hwnd = renderControl.Handle;
            properties.PixelSize = new Size2(renderControl.ClientSize.Width, renderControl.ClientSize.Height);
            properties.PresentOptions = PresentOptions.None;

            RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)), properties);
            RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive;
            RenderTarget2D.TextAntialiasMode = TextAntialiasMode.Cleartype;

            SceneColorBrush = new SolidColorBrush(RenderTarget2D, Color.Black);

            renderControl.Paint += new PaintEventHandler(renderControl_Paint);
            renderControl.Resize += new EventHandler(renderControl_Resize);
        }
コード例 #40
0
 private void CreateRenderObjects()
 {
     RenderTargetProperties renderTargetProperties = new RenderTargetProperties();
     HwndRenderTargetProperties hwRenderTargetProperties = new HwndRenderTargetProperties()
     {
         Hwnd = this.Handle,
         PixelSize = new Size2(ClientSize.Width, ClientSize.Height)
     };
     renderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwRenderTargetProperties);
     renderObjectsCreated = true;
     OnCreateRenderObjects(EventArgs.Empty);
 }
コード例 #41
0
ファイル: DialogPane.cs プロジェクト: 2max968/Kritzelv2
        public DialogPane(Control dialog, Bitmap buffer, MainWindow.Callback callback, params Control[] controls)
        {
            InitializeComponent();
            timerFadeIn.Tick    += Timer_Tick;
            timerFadeIn.Interval = 10;
            timerFadeOut.Tick   += TimerFadeOut_Tick;
            this.Resize         += DialogPane_Resize;

            // Create Shadow
            //using (Graphics g = Graphics.FromImage(buffer))
            //{
            //    Renderer.Effects.DrawSlowBoxShadow(g, dialog.Bounds, 8);
            //}

            this.buffer   = buffer;
            this.SizeMode = PictureBoxSizeMode.StretchImage;
            this.Image    = (Bitmap)buffer.Clone();
            this.callback = callback;
            this.dialog   = dialog;
            this.controls = controls;

            this.Location = new Point(0, 0);
            this.Size     = new Size(buffer.Width, buffer.Height);
            Anchor        = AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Top;

            if (dialog != null)
            {
                Controls.Add(dialog);
                dialog.Show();
                if (dialog is IClosable)
                {
                    ((IClosable)dialog).AddCloseHandler(delegate()
                    {
                        Close();
                    });
                }
            }

            MouseClick += new MouseEventHandler(delegate(object s, MouseEventArgs args)
            {
                Close();
            });

            timerFadeIn.Start();
            stp.Start();

            factory      = new d2d.Factory(d2d.FactoryType.SingleThreaded);
            renderTarget = new d2d.WindowRenderTarget(factory, new d2d.RenderTargetProperties()
            {
            }, new d2d.HwndRenderTargetProperties()
            {
                Hwnd           = this.Handle,
                PresentOptions = d2d.PresentOptions.Immediately,
                PixelSize      = new Size2(this.ClientSize.Width, this.ClientSize.Height)
            });
            bmp = Renderer.Image.LoadBitmap(renderTarget, buffer);
            DialogPane_Paint(null, null);

            this.Paint    += DialogPane_Paint;
            this.Disposed += DialogPane_Disposed;
        }
コード例 #42
0
        /// <summary>
        /// Inits the direct2D and direct write.
        /// </summary>
        private void InitDirect2DAndDirectWrite()
        {
            Factory2D = new SharpDX.Direct2D1.Factory();
            FactoryDWrite = new SharpDX.DirectWrite.Factory();

            var properties = new HwndRenderTargetProperties {Hwnd = Handle, PixelSize = ClientSize, PresentOptions = PresentOptions.None};

            RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(), properties)
                                 {
                                     AntialiasMode = AntialiasMode.PerPrimitive,
                                     TextAntialiasMode = TextAntialiasMode.Cleartype
                                 };

            SceneColorBrush = new SolidColorBrush(RenderTarget2D, new Color4(1, 0, 0, 0));

            CustomTextRenderer = new CustomTextRenderer(Factory2D, RenderTarget2D);
        }
コード例 #43
0
 private void Draw2DCircle(WindowRenderTarget device, Vector3 origin, float radius, int segments, Color color, float thickness, CSGOImplementation csgo)
 {
     Vector3[] circPoints = Geometry.Create3DFlatCircle(
         origin,
         radius,
         segments);
     Vector2[] scrCircPoints = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, circPoints);
     DrawLines(device, color, thickness, scrCircPoints);
 }
コード例 #44
0
ファイル: MapViewer.cs プロジェクト: rantingmong/blocm
        private void InitD2D()
        {
            factory = new D2D.Factory();

            windowRenderTarget = new D2D.WindowRenderTarget(factory,
                                                            new D2D.RenderTargetProperties(
                                                                new D2D.PixelFormat(Format.R8G8B8A8_UNorm,
                                                                                    D2D.AlphaMode.Premultiplied)),
                                                            new D2D.HwndRenderTargetProperties
                                                                {
                                                                    Hwnd = Handle,
                                                                    PixelSize =
                                                                        new DrawingSize(ClientSize.Width,
                                                                                        ClientSize.Height),
                                                                    PresentOptions = D2D.PresentOptions.Immediately
                                                                });
        }
コード例 #45
0
        private void DrawW2SBox(WindowRenderTarget device, Color color, Vector3 bottomCenter, float width, float height, float degreeRotation, float strokeWidth = 1f)
        {
            Vector3[] pointsBottom = Geometry.Create3DFlatBox(bottomCenter, width, degreeRotation);
            Vector3[] pointsUpper =
                Geometry.OffsetVectors(
                    Vector3.UnitZ * height,
                    Geometry.CopyVectors(pointsBottom)
                );

            Vector2[] pointsBottom2D = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, pointsBottom);
            Vector2[] pointsUpper2D = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, pointsUpper);

            foreach (Vector2 pnt in pointsBottom2D)
                if (pnt == Vector2.Zero)
                    return;
            foreach (Vector2 pnt in pointsUpper2D)
                if (pnt == Vector2.Zero)
                    return;
            this.DrawLines(device, color, strokeWidth, pointsBottom2D);
            this.DrawLines(device, color, strokeWidth, pointsUpper2D);
            this.ConnectLines(device, color, strokeWidth, pointsBottom2D, pointsUpper2D);
        }
コード例 #46
0
 private void DrawBones(WindowRenderTarget device, Color clr, Vector2[] bones, float thickness, Team team)
 {
     Vector2 last = bones[0];
     for (int i = 1; i < bones.Length; i++)
     {
         DrawLine(
             device,
             clr,
             bones[i].X,
             bones[i].Y,
             last.X,
             last.Y,
             thickness);
         last = bones[i];
     }
 }
コード例 #47
0
 private void DrawAngle(WindowRenderTarget device, float x, float y, float angle, string text)
 {
     Vector2 vecOrigin = new Vector2(x, y);
     Vector2 vecRotated = new Vector2(x, y - 100);
     vecRotated = Geometry.RotatePoint(vecRotated, vecOrigin, angle);
     float pixelPerDeg = 1680f / 90f;
     this.DrawLine(device, Color.Red, vecOrigin.X, vecOrigin.Y, vecRotated.X, vecRotated.Y, 1f);
     this.DrawText(device, Color.Red, vecOrigin.X, vecOrigin.Y + 10f, 100f, 20f, String.Format("{0}: {1}, {2}px", text, Math.Round(angle, 2), Math.Round(pixelPerDeg * angle, 2)), this.Font);
 }
コード例 #48
0
 private void DisposeRenderObjects()
 {
     if(renderObjectsCreated)
     {
         renderTarget.Dispose();
         renderTarget = null;
         OnDisposeRenderObjects(EventArgs.Empty);
         renderObjectsCreated = false;
     }
 }