HP unveils a new class of Windows 10 gaming devices

After announcing the OMEN by HP portfolio back in May, HP Inc. unveiled a new class of Windows 10 gaming computers today at their event in New York City and has them in display at Gamescom (HP Stand #A053, Hall 9.1) in Germany. The new OMEN X Desktop, OMEN X by HP Curved Display, OMEN by HP with SteelSeries accessories and the OMEN 17 Laptop are all built for you to have the ultimate PC gaming experience.

Let’s take a look at these new and re-designed devices:

The new HP OMEN X Desktop with Windows 10

The new OMEN X Desktop is a fully customizable, powerful desktop for the gamer who wants the best performance, thermal management and cutting-edge design. This desktop is built with a revolutionary thermal management solution, which includes a tri-chamber design with dedicated cooling for each chamber.

Click to view slideshow.

The tool-less access to the internals, clean cable management features and a toolkit hidden in the chassis accommodates any customization you might want. You can also purchase an empty OMEN X Desktop chassis as a standalone option for a completely immersive do-it-yourself PC experience.

To guarantee every high-end PC gamer’s needs are met with the OMEN X Desktop, HP is partnering with Maingear to build customized PCs for the ultra-enthusiast. Maingear is known for exceptional build quality, and together with HP, gamers can design the ultimate custom OMEN X build. The Maingear OMEN X Desktop will be available to customers in early 2017 and pricing will vary.

Other features include:

  • Powered by Windows 10
  • DirectX 12 capable for stunning gaming visuals
  • Four different modes: Single Color, Color Show, System Monitor and Audio Show
  • The OMEN Control software provides complete design control, allowing for custom LED light modifications and brightness adjustments in real time.
  • 6th generation Intel Core i5/i7 over-clockable processors and the latest graphics technology, up to dual NVIDIA GeForce GTX 1080 and up to dual AMD Radeon R9 Fury X
  • NVME PCIe connected SSDs
  • Includes support for up to three 120mm liquid cooling radiators with with top mounted exhaust vents and a stand that lifts the case off the ground to help pull cool air in, allowing for maximum ventilation.

Pricing and Availability: The OMEN X Desktop is planned to be available at select US retailers on October 16 with a configuration starting at $2,099.99. The OMEN X is planned to be available on HP.com on August 17 starting at $1,799 with the standalone OMEN X chassis with a starting price at $599.99. For more information, visit HP.com.

The OMEN 17 Laptop with Windows 10

The latest 17.3” diagonal OMEN Laptop is designed from top-to-bottom with the performance gamer in mind. It’s only 32.9 mm thin and weighs only seven pounds, making it now one of the most powerful and portable gaming laptops on the market. This OMEN notebook is built ready for virtual reality, with up to 4K display resolution with 300 nits for another level for sharpness.

This notebook includes great Windows 10 features – it supports your personal digital assistant Cortana with voice integration for natural interaction with your device. You can also login easily and securely with Windows Hello using the optional Intel RealSense camera by using your face in place of typing a password.

Other features include:

  • Powered by Windows 10
  • DirectX 12 capable for spectacular gaming graphics
  • The latest NVIDIA GeForce GTX 1060 and 1070 graphics technology
  • G-SYNC display technology, which optimizes gaming by synchronizing the display refresh rates to the GPU
  • 6th generation Intel Core i5/i7
  • PCIe SSD for rapid data access for faster load times
  • Dragon Red backlit keyboard
  • Quad speakers with audio by Bang & Olufsen and HP Audio Boost, great for Skype or gaming audio

Pricing and Availability: The OMEN 17 Laptop is planned to be available on HP.com starting at $1,599.99. For more information, visit HP.com.

OMEN by HP with SteelSeries Accessories

HP is collaborating with SteelSeries to introduce a line of accessories designed to heighten gameplay and provide the utmost competitive advantage. The OMEN platform software is pre-installed on OMEN PCs and offered on both the OMEN keyboard and OMEN mouse, so you can easily take advantage of its many features with the cross-platform support. It also features a cloud syncing system to make sure you always have your favorite settings.

The SteelSeries Accessories include:

  • The OMEN Headset with SteelSeries features lightweight headset suspension construction to evenly spread the weight of the headset over the entire band, allowing gamers to play longer, more comfortably.
  • The OMEN Keyboard with SteelSeries enables personalization with over 16.8 million colors to create unique color schemes and allow for color changes in response to gameplay action.
  • The OMEN Mouse with SteelSeries includes features for unmatched performance including customization like RGB illumination, 6 fully programmable buttons for quicker action, and Zero hardware acceleration for 1:1 tracking and precise movements.
  • The OMEN Mouse Pad with SteelSeries provides a high-quality, non-slip rubber base and the precision professionals rely on with a durable smooth, surface

Pricing and Availability: The OMEN by HP with SteelSeries Accessories will be available in mid-September 2016 at HP.com and in select retailers starting at $79.99 for the OMEN Headset, $99.99 for the OMEN Keyboard, $59.99 for the OMEN Mouse and $19.99 for the OMEN Mouse Pad. For more information, visit HP.com.

OMEN X by HP Curved Display

To round out the OMEN ecosystem, HP is introducing the HP X by Curved Display, which will be available in early 2017, to add a new level of realism and immersion. The curved display is the first from HP to offer NVIDIA G-Sync Technology, integrating the latest technologies and more choices for customers seeking wide viewing angles and a smooth gaming experience.

Pricing and Availability: The OMEN X by HP Curved Display will be available on HP Shopping and with select retailers starting in early 2017. For more information, visit HP.com.

HP’s newest gaming PCs built with Windows 10 are perfect for the ultimate gaming experience. Exact specifications, prices, and availability will vary by region. Visit HP.com to learn more, and look for them on shelves as soon as this week!

Creating a Custom Ruler with DirectInk


1_InkCanvasRuler_RulerHeader

The Windows 10 Anniversary Update comes with a great set of enhancements to digital ink for both the user and developer. Along with gaining knowledge from general inking resources, you will finish this post knowing how to create a custom ruler with DirectInk.

There has been a lot of excitement and discussion around these features since they were first shown at //build/ 2016. Li-Chen’s “Closer Look at Windows Ink” post from April, and Pete’s recent “The Ink Canvas and Ruler: combining art and technology” both dive into some of those enhancements, including the new Windows Ink Workspace, Sticky Notes and Sketchpad.

For the developer, Pete’s post gets you started in adding ink to your app and you can go on a deeper dive with Scott and Xiao from the Windows Inking team in their //build/ 2016 session. Watch here: “Pen and Ink: Inking at the Speed of Thought

That session included a discussion on how the new and greatly improved InkToolbar control is now a part of the platform, and how the bar for producing an inking experience has been lowered so that with “just 2 lines of markup” you can produce a very usable UI offering three different types of pen.

The snippet below wraps those “2 lines of markup” into a Grid container.

InkCanvasRuler Code1

These pen types (ballpoint, pencil, highlighter) are then customizable in terms of color and size, as this image illustrates.

InkCanvasRuler PenTypes

Those “2 lines of markup” also give you an eraser button, and the InkToolbar opens up its theming, standard controls, and the option for you as a developer to add your own controls.

This combination of InkToolbar and InkCanvas makes getting started with digital inking pretty easy with the Anniversary Update.

The Ruler
InkCanvasRuler Line TheRuler (1)

One of the most innovative and interesting things that the InkToolbar control does by default is to provide a button that enables the ruler, as shown below.

InkCanvasRuler StraightLines (1)

The platform provides for simultaneous touch and pen so that the user can manipulate the ruler with one hand while drawing with the other.  It’s one of those things that has to be tried rather than explained, as there’s a specific feeling that comes from drawing with a virtual ruler for the first time.

Those who have previously used platform pieces like InkCanvas may wonder how this ruler is implemented as it’s new in the Anniversary Update and relies upon some additions to the DirectInk APIs.

One of the big advantages of DirectInk is that the software stack works closely with the hardware so ink can be smoothly captured from the digitizer and presented on the screen.

The documentation for DirectInk talks in terms of “wet” and “dry” ink; the input is processed on a low-latency background thread and rendered “wet” until the ink stroke is completed and picked up by the UI thread to be rendered “dry” onto the InkCanvas. For specialized scenarios where a developer needs complete control over the ink rendering, it is possible to implement “custom drying” and take over full responsibility of rendering dry ink in any way that the application needs to. There are samples of these techniques on GitHub using C# and Win2D and using C++ and Direct2D.

However, what was not previously possible was to add code to affect the drawing strokes a user generated as they were drawing “wet” ink onto the InkCanvas. With the Anniversary Update, that becomes possible and opens the door to custom implementations similar in nature to the ruler.

Custom Rulers – Simulating Graph Paper
InkCanvasRuler Line rCustomRulers (1)

I associate drawing with a ruler with being back at school and using graph paper to make it easy to draw boxes and lines. Let’s illustrate the basics of a custom ruler by using a surface that gives the appearance of graph paper.

With that in mind, I wrote a custom user control called GraphPaperUserControl; it is available from this GraphPaperControl GitHub repository.

This control uses Win2D to tile its display surface with a light blue grid of a size that is controlled by the control’s single property, GridSize. The GitHub repository includes a simple test application which binds the GridSize property to the value of a Slider as shown in the diagram below.

InkCanvasRuler_GraphPaper

I am going to use this control in a separate, Windows 10 Anniversary Update project, so I used Visual Studio and the New Project menu to create a “Blank App (Universal Windows)” in C# and then copied in the XAML and code-behind file for that GraphPaperUserControl and added a reference to the Win2D.uwp NuGet package.

I then made a simple, layered interface in my MainPage.xaml file using this control in combination with an InkCanvas and an InkToolbar, and a simple TextBlock to display one of three modes of operation.


  <Grid
    Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <ctrl:GraphPaperUserControl
      xmlns:ctrl="using:GraphPaperControl.UserControls"
      x:Name="graphPaper" />
    <InkCanvas
      x:Name="inkCanvas"
      ManipulationDelta="OnInkCanvasManipulationDelta"
      ManipulationMode="Scale"
      Tapped="OnInkCanvasTapped" />
    <InkToolbar
      HorizontalAlignment="Right"
      VerticalAlignment="Top"
      TargetInkCanvas="{Binding ElementName=inkCanvas}" />
    <TextBlock
      x:Name="txtMode"
      FontSize="18"
      HorizontalAlignment="Left"
      VerticalAlignment="Bottom"
      Margin="48" />
  </Grid>

Note that the ManipulationDelta event is being handled here and that the ManipulationMode is set to Scale, meaning that the user can perform a “pinch to scale” gesture on the InkCanvas.

The accompanying code-behind below includes the event handler that changes the GridSize on the underlying GraphPaperUserControl in response to this gesture. It also includes a handler for the tapped event that checks for a touch event before toggling between one of three drawing modes – Freeform drawing, Snap to X and Snap to Y.


namespace InkArticleApp
{
  using System;
  using Windows.Devices.Input;
  using Windows.UI.Xaml.Controls;
  using Windows.UI.Xaml.Input;

  public sealed partial class MainPage : Page
  {
    enum Mode
    {
      Freeform = 0,
      SnapX = 1,
      SnapY = 2
    }
    public MainPage()
    {
      this.InitializeComponent();
      this.graphPaper.GridSize = BASE_GRID_SIZE;
      this.currentScaleFactor = 1.0m;
      this.currentMode = Mode.Freeform;
      this.UpdateModeText();
    }
    void UpdateModeText() => this.txtMode.Text = this.currentMode.ToString();

    void OnInkCanvasManipulationDelta(object sender, ManipulationDeltaRoutedEventArgs e)
    {
      var newScaleFactor = (decimal)e.Delta.Scale * this.currentScaleFactor;

      if ((newScaleFactor <= MAX_SCALE_FACTOR) && (newScaleFactor >= MIN_SCALE_FACTOR))
      {
        this.currentScaleFactor = newScaleFactor;

        var newGridSize = (int)(this.currentScaleFactor * BASE_GRID_SIZE);

        if (newGridSize != this.graphPaper.GridSize)
        {
          this.graphPaper.GridSize = newGridSize;
        }
      }
    }
    void OnInkCanvasTapped(object sender, TappedRoutedEventArgs e)
    {
      if (e.PointerDeviceType == PointerDeviceType.Touch)
      {
        // Apologies for doing such a horrible thing to an enum.
        this.currentMode = 
          (Mode)((((int)this.currentMode) + 1) % ((int)Mode.SnapY + 1));

        this.UpdateModeText();
      }
    }
    Mode currentMode;
    decimal currentScaleFactor;
    static readonly decimal MAX_SCALE_FACTOR = 8.0m;
    static readonly decimal MIN_SCALE_FACTOR = 0.5m;
    static readonly int BASE_GRID_SIZE = 20;
  }
}

This UI presents graph paper “underneath” the InkCanvas, and the grid drawn on the graph paper can be resized by a pinch gesture and the drawing mode can be toggled by tapping. The screenshot below shows this in use. It’s key to note that handling these touch events does not alter the inking experience.

9_InkCanvasRuler_SmallGrid

10_InkCanvasRuler_SmallGrid

Snapping Ink to Grid Lines
InkCanvasRuler Line rCustomRulers (1)

The remaining piece of work in this small example is to snap “wet” ink to the grid lines as it is being drawn onto the InkCanvas in accordance with the drawing mode that the user has set by tapping on the canvas.

This involves handling new events in the Anniversary Update APIs presented by the class CoreWetStrokeUpdateSource from the namespace Windows.UI.Input.Inking.Core.

The CoreWetStrokeUpdateSource class provides a static factory method for construction; it takes the InkPresenter as its argument and then the returned object fires the set of “wet” ink events representing stroke start, continuing, stop, canceled and completed.

I added a Loaded handler to my page and handled only two of those events in my example.


    /// <summary>
    /// event handler for MainPage.Loaded
    /// </summary>
    void OnLoaded(object sender, Windows.UI.Xaml.RoutedEventArgs e)
    {
      // Added a member variable of type CoreWetStrokeUpdateSource called 'wetUpdateSource'
      this.wetUpdateSource = CoreWetStrokeUpdateSource.Create(this.inkCanvas.InkPresenter);
      this.wetUpdateSource.WetStrokeStarting += OnStrokeStarting;
      this.wetUpdateSource.WetStrokeContinuing += OnStrokeContinuing;
    }

These events are fired on the dedicated background input processing thread and, naturally, the intention would be to run as little code as possible to keep the inking experience smooth and fluid.

In my scenario, I handle the WetStrokeStarting event by looking at the first ink point produced and then (depending on the current drawing mode) storing the X or Y coordinate that any ink should be snapped to until the next ink stroke begins.

Note that the CoreWetStrokeUpdateEventArgs argument that is passed to the event handler is used here only for the NewInkPoints property but it does contain additional information including the PointerId. Also, the code presented here is more for illustration of the ideas than optimized for performance.


    void OnStrokeStarting(CoreWetStrokeUpdateSource sender, CoreWetStrokeUpdateEventArgs args)
    {
      // I am assuming that we do get a first ink point.
      InkPoint firstPoint = args.NewInkPoints.First();

      // as the stroke is starting, reset our member variables which store
      // which X or Y point we want to snap to.
      this.snapX = this.snapY = null;

      // now decide whether we need to set up a snap point for the X value or
      // one for the Y value.
      if (this.currentMode == Mode.SnapX)
      {
        this.snapX = this.NearestGridSizeMultiple(firstPoint.Position.X);
      }
      else if (this.currentMode == Mode.SnapY)
      {
        this.snapY = this.NearestGridSizeMultiple(firstPoint.Position.Y);
      }
      this.SnapPoints(args.NewInkPoints);
    }
    double? snapX;
    double? snapY;

This handler function makes use of the NearestGridSizeMultiple function to determine the X or Y value of the nearest grid line.

Returning to the earlier discussion around threading, note that the comment in the method below relates to the addition of a new member variable which keeps track of the current grid size of the graph paper even though the GraphPaperUserControl already stores this in its GridSize property.


    double NearestGridSizeMultiple(double value)
    {
      // Note. I have added a new member variable 'currentGridSize' which I keep
      // in sync with the GridSize of the GraphPaperUserControl.
      // This is because this code runs on a non-UI thread so it cannot simply
      // call into that property on the user control which has thread affinity.

      var divisor = value / this.currentGridSize;
      var fractional = divisor - Math.Floor(divisor);

      if (fractional >= 0.5)
      {
        divisor = Math.Ceiling(divisor);
      }
      else
      {
        divisor = Math.Floor(divisor);
      }
      return (divisor * this.currentGridSize);
    }
    int currentGridSize;

Lastly, the member function SnapPoints is invoked on the newly produced “wet” InkPoints so that the original values can be replaced with new values that are identical except their X or Y coordinates are snapped to the nearest grid lines if snap points have been determined.


void SnapPoints(IList<InkPoint> newInkPoints)
    {
      // do we need to do any snapping?
      if (this.currentMode != Mode.Freeform)
      {
        for (int i = 0; i < newInkPoints.Count; i++)
        {
          if (this.snapX.HasValue)
          {
            // replace this point with the same point but with the X value snapped.
            newInkPoints[i] = new InkPoint(
              new Point(this.snapX.Value, newInkPoints[i].Position.Y),
              newInkPoints[i].Pressure);
          }
          else if (this.snapY.HasValue)
          {
            // replace this point with the same point but with the Y value snapped.
            newInkPoints[i] = new InkPoint(
              new Point(newInkPoints[i].Position.X, this.snapY.Value),
              newInkPoints[i].Pressure);
          }
        }
      }
    }

That same member function is invoked from the event handler, which deals with the continuation of the “wet” ink stroke so the ink points produced can also be snapped.


    void OnStrokeContinuing(CoreWetStrokeUpdateSource sender, CoreWetStrokeUpdateEventArgs args)
    {
      this.SnapPoints(args.NewInkPoints);
    }

Those small pieces of code are enough to change the behavior of the ink as it is being drawn, as the screenshots below illustrate.

12_InkCanvasRuler_Freeform

Wrapping Up
InkCanvasRuler Line TheRuler (1)

The full code for the article is present in this InkArticleApp GitHub repository for you to download and experiment with, and use as the basis for your own experiments.

The graph paper example here is a simple one but these new capabilities open up all kinds of scenarios for different shapes and sizes of rulers and stencils and perhaps more complex examples for particular types of diagramming. It’s not hard to imagine tools like Visio implementing custom rulers for diagramming buildings or network diagrams.

No doubt, you have your own scenarios that could benefit from digital ink and we look forward to seeing what you build.

Mike Taulty, Developer Evangelist, Microsoft UK

mtaulty.com
Twitter: @mtaulty

Interested in more capabilities with inking?

Check out this guide to pen and stylus interactions on MSDN: “Pen and stylus interactions in UWP apps

And this recent episode of Channel9’s Context show, focusing on inking with lots of code demos:

4_InkCanvasRuler_ContextScreenshot

Get started with Windows Visual Studio!

Prolimatech Megahalems & 3x Noctua 120mm ULN Fans

Recently bought a Corsair AIO cooler, so no longer require my heatsink or as many case fans.

The Pro Mega is in excellent condition and still performing as good as when I had it new. It has been regularly cleaned to the best of my ability. It comes with the 4 metal fan clips, 3 metal pieces to secure to board and underneath bracket to fit Haswell CPUs, but I believe fits other models, but please check.

£30 all in

3 Noctua 120mm Nf-12A ULN fan. These are incredibly quiet, high air…

Prolimatech Megahalems & 3x Noctua 120mm ULN Fans

Recap: The Future of Gaming on UWP – GDC Europe Twitter Chat

This year’s Game Developers Conference Europe (GDC Europe) proved that there’s a lot to be excited about if you’re a Windows game developer.

Play Anywhere, Xbox’s Project Scorpio, ID@Xbox – those are just a few of the ways Windows and the Universal Windows Platform (UWP) are making it even easier to build an amazing game with the most advanced features and, most importantly, get people playing.

Alex Teodorescu-Badia, Senior Product Manager for Gaming, Windows Developer Platform, hosted a session about the future of UWP gaming at the event. For those who couldn’t attend in-person, Alex answered questions in a Twitter chat after the session ended.

There, he provided a peek into Microsoft’s plans and roadmap for building the best place for indie game developers on Windows devices including OS-level updates coming this year in Windows, platform-agnostic development approaches, partner tools and engines, and tips on how to maximize your game’s revenue.

Keep reading to see highlights from our #GDCE16 Twitter chat, from virtual reality support in Xbox’s Project Scorpio to the best guides for beginner game developers.

As always, tweet us if you have any more questions about game development or becoming a UWP dev!

Surface Pro 3 – Intel Core i5 – 256GB

Microsoft Surface Pro 3
Intel Core i5
256GB SSD
8GB RAM
2 Chargers
Has accidental damage support until Dec 2016
US Type Cover Keyboard
Excellent Condition Throughout
Running Windows 10

Will trade for a high end/gaming laptop.

Price and currency: 515
Delivery: Delivery cost is included
Payment method: BT
Location: London NW9
Advertised elsewhere?: Advertised elsewhere
Prefer goods collected?: I prefer the goods to be collected…

Surface Pro 3 – Intel Core i5 – 256GB

Original Apple 85W MagSafe 2 Power Adaptor and Cord.

Original Apple MagSafe 2 Power Adaptor and Cord.

Excellent Condition.

Used 4 times.

RRP £64.99

For sale at £45 inc UK Delivery or collection welcome from Norwich.

Compatible with computers that use the 85W MagSafe 2 Adapter

Adapter type

  • MacBook Pro (Retina, 15 inch, Mid 2015)
  • MacBook Pro (Retina, 15-inch, Mid 2014)
  • MacBook Pro (Retina, 15-inch, Late 2013)
  • Macbook Pro (Retina, 15-inch, Early 2013)
  • MacBook Pro (Retina, Mid 2012)…

Original Apple 85W MagSafe 2 Power Adaptor and Cord.

Surface Pro 4 Type Cover

As above. Lets see what colour you have. I want the new version with spaced out keys not the old Pro3/4 keyboard.

Thanks in advance.

Location: London

______________________________________________________
This message is automatically inserted in all classifieds forum threads.
By replying to this thread you agree to abide by the trading rules detailed here.
Please be advised, all buyers and sellers…

Surface Pro 4 Type Cover