Corsair Air 540 + LP Vengeance DDR3 16GB

Please post if you have the case / RAM.

RAM preferred in black.

Thanks.

Location: Carlisle

______________________________________________________
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 should satisfy themselves that the other party is genuine by…

Corsair Air 540 + LP Vengeance DDR3 16GB

Intro to porting Unity 3D games to UWP: Building and deploying

Hero_FINAL-Unity

Did you know that you can easily get your Unity 3D game into the Windows Store simply by creating it in Unity or porting an existing game to the Universal Windows Platform (UWP)? That’s a big deal, because the Windows Store opens up the whole spectrum of Windows 10 devices, and their users, to your game: PCs, tablets, Windows 10 phones, Xbox One, and even HoloLens.

In this post, we’re going to go over how to deploy a game from Unity 3D to a UWP project and then build your new UWP game in Visual Studio.

What you need

To develop, compile, and submit a Unity game to the Windows Store, you will need:

  • Unity – Either the Unity free version or Unity Pro will work. The add-ons for publishing to the Windows Store are free for both basic and Unity Pro users.
  • Visual Studio – You can use any Visual Studio SKU, including the free Visual Studio Community. To target Universal Windows Platform, you will need at least Visual Studio 2015 Update 1.
  • Windows 10 – If you do not own a Windows 10 license, you can get a 90-day evaluation version. If you are running Mac OS X or will install on Apple hardware, check different options for installing using Boot Camp, VMWare, or Parallels.
  • Windows Store developer account – This will be needed to submit your game to the Windows Store. During this process you will register and get verified as an individual or as a business who can submit apps and games to the store. This registration allows you to submit apps and games to PC, Phone, Tablet and also in the future to HoloLens and Xbox. There is a small registration fee for individuals to sign up, although free Dev Center accounts are often available through Microsoft-sponsored programs (e.g. for startups).
  • Windows 10 test devices – While the Visual Studio simulators and emulators can replicate multi-touch and different display resolutions, it is recommended that you test on a real ARM mobile device with touch capability if you are developing a mobile/touch experience.

In this post, we will use Unity 5.3.3, Visual Studio 2015 Update 1, and Windows 10 Version 1511. For your benefit, it is recommended that you use at least Unity 5.3.2. Newer versions may have a different application programming interface.

Configuring developer mode in Windows 10

For Windows 10, whether using a desktop, tablet, or phone, you need to enable that device for development under System Settings.

To do so, navigate to System Settings and choose “Update & security.” Then choose, “For developers.” From here, you can simply select and enable “Developer mode.”

1_developerfeatures

Deploying your game from Unity

For the purposes of this post, let’s assume that you have already created a game in Unity. If you haven’t, though, there are several great Unity 3D tutorials available to get you started.

If your game was originally built for iOS or Android, it is important that you don’t have any platform specific controls or DLLs before attempting this. If you have platform specific code or libraries, the process outlined in this post may throw errors before you get to the end.

To start, we’re going to open up your Unity project and configure the build settings. To configure your settings in Unity, first click “File,” then “Build Settings.”

 

2_buildsettings

Next, choose Windows Store in the Platform Window. Then select Universal 10 in the SDK dropdown.

3_universal10

Select XAML in the UWP Build Type dropdown.

4_XAML

Next, click the Player Settings… button.

5_playersettings

Enter your game details in the “Player Settings” window such as your default icon and product name. Your build settings are now properly configured in Unity3D to allow you to export to UWP.

6_gamesettings

Click on the Build button in the Build Settings window. You will be prompted with a Build Windows Store dialog to select a folder for building your game.

7_selectfolder

Once you have selected the folder, Unity will begin building your game, targeting the platform you selected. This can take several minutes if you have a lot of assets.

8_build

A Windows Explorer window should now display the folder containing all the files generated by Unity.

9_buildfolder

You will need to remember the location of your Visual Studio solution for the next step.

Building your UWP game in Visual Studio

From here on out, you’ll be working in Visual Studio. We’ve already exported your Unity 3D game into a UWP solution.

To get started in Visual Studio, navigate to the folder where you deployed the solution and open it in Visual Studio.

In order to distribute your UWP app to other users, either on the store or for sideloading, you need to follow the steps to create an appxupload package for it. When you create the appxupload, an additional appx package will be generated to use for testing and sideloading.

First, select either x86 or x64 from the platform dropdown as the platform.

10_appxupload

From the menu, click Build -> Build Solution or press F6.

11_buildsolution

Allow the NuGet Package Manager to restore packages.

12_packagerestore

Set the target to Local Machine. Then click Run. You can watch the progress of the build in the Output window.

13_localmachine

Finally, verify that the build succeeded.

14_buildsucceeded

Now you are ready to deploy your app in Windows Store.

Note: If you intend to share the app with friends outside of Windows Store first, you can also sideload this app to install it on any Windows 10 device.

You will need to associate your app to with the Windows Store. To do so, navigate to the Project menu and choose Store -> Associate App with the Store….

15_associateapp

Your app is now enabled for test purchase and notification scenarios if you choose to do so.

When you associate your app with the store, the following values are downloaded to the app manifest file for the current project on your local machine:

  • Package Display Name
  • Package Name
  • Publisher ID
  • Publisher Display Name
  • Version

Note that you can override the default package.appxmanifest file by creating a custom .xml file for the manifest. As a general rule, however, you do not want to do this and really don’t want to alter the manifest file at all if you aren’t completely sure of what you are doing.

Wrapping Up

In this post, we’ve covered how to take your Unity 3D game and prepare it for deployment to the Windows Store. By using Unity 3D and Visual Studio together in your development toolchain, you can gain a much wider audience for your games. Just as exciting, you can potentially deploy your games to a greater variety of devices from tablets to phablets to gaming consoles to the latest emerging technologies built around Windows 10.

A Closer Look at Some Awesome Windows 10 Gaming Machines

At the recent Xbox Showcase event in San Francisco, we had a chance to take a look at some of this year’s biggest Windows 10 games, including recently released titles like Gears of War: Ultimate Edition, Killer Instinct: Season 3, and Quantum Break. Those games were all shown on a number of Windows 10 desktop and notebook PCs from a bunch of our great partners.

In the video above, we take a closer look at some of the latest and greatest Windows 10 gaming hardware around. On the desktop side, powerhouses like the Alienware Area-51 and Acer Predator G6 offer build-from-the-ground-up gaming experiences and look great doing it. The Razer Blade, on the other hand, gives players a full gaming performance on the go, while remaining incredibly thin and light. All of these provide the horsepower to allow for ultrahigh graphics settings with smooth frame rates and 4K resolutions!

To get the full rundown on all of the Windows 10 gaming machines shown at the Xbox Showcase event, head over to Xbox Wire.

i5 2500k, Dell U2412M, Patriot 16GB DDR3, Megahalems, Samsung 840 Pro 256GB SSD, Corsair HX520W PSU,

Prolimatech Black Megahalems CPU Cooler – £40 collected as it’s on the heavy side. Original box and accessories.
View attachment 668673

View attachment 668672

Corsair HX520W Modular PSU – 2x(6+2) pci-e, 2×2 Sata, 1×2 molex
Looking for £40 collected.
View attachment 704917

View attachment 704918

Samsung 840 Pro 256GB – I love this drive but I’ve recently replaced it with a M2 ssd to save space in my SFF case. Looking for £70 delivered. I think I have the original…

i5 2500k, Dell U2412M, Patriot 16GB DDR3, Megahalems, Samsung 840 Pro 256GB SSD, Corsair HX520W PSU,

WebM, VP9 and Opus Support in Microsoft Edge

Starting with EdgeHTML 14.14291, the open-source WebM container format and the VP9 video and Opus audio codecs are supported in Microsoft Edge. These are available to websites that use Media Source Extensions (MSE) to adaptively stream video content. Windows Web Apps (built on the same Edge APIs) will also be able to use WebM streams containing VP9 and Opus. This change will be available in stable releases starting with the Windows 10 Anniversary Update.

VP9 is an efficient open source video codec developed as part of the WebM Project by Google. The VP9 and WebM project team recently joined the Alliance for Open Media effort where their work on VP9 is expected to be a significant contribution to the next generation of open-source, royalty-free video codecs.

Opus was developed by the Xiph Foundation to support both bandwidth-efficient speech/RTC applications as well as high-quality media playback – all within one codec. Opus is the primary audio codec paired with VP9 in the WebM specification.

We are adding support for these formats to simplify building interoperable websites, and to provide an alternative format for compressing 4K video content. To try them in Microsoft Edge, please install the most recent Windows 10 Insider Build.

Background

Microsoft has been providing support for Media Source Extensions (MSE) since Windows 8.1, initially through support for ISO-Base Media File Format (ISO-BMFF) content that uses fragmented MP4 containers with H.264/AVC video and AAC audio. More recently, we added support within MP4 for H.265/HEVC video and Dolby Digital multi-channel audio, formats targeted at high-performance media.

The WebM Byte Stream Format has existed for some time. It defines the specifics of using VP9 and Opus with MSE. VP9 is an open source video codec that has efficient compression well suited to HD and 4K streaming. Opus, similarly, is a very efficient open source audio codec. They are used together by some prominent websites – notably YouTube – that value them for this efficiency, especially on content with greater than 1080p resolution. Adding WebM, VP9 and Opus to Microsoft Edge means the full experience on these websites will be possible in the Edge browser.

VP9 and Opus Performance

Our implementation of VP9 will support software decoding and, when supported by the device, hardware decoding via the DXVA interface. Video decoding is computationally complex, so the best experience will be seen on computers that have VP9 hardware acceleration which is optimized for 4K decoding support, a feature which will start to become common on devices later this year. Software decoding can yield good performance, but will work best on more powerful desktop or laptop computers.

There’s a side effect of high computing load on software decode:  system power consumption is elevated. The elevation is highest on 4K content because the computing load correlates closely with video resolution. If we compare software decode to hardware accelerated decode, software decode may consume 20% more total power when viewing a 1080p video, and up to 80% more power viewing 2160p. The following charts compare hardware video decode to software video decode at different resolutions on a mid-level laptop computer:

Bar chart comparing software decode power consumption versus hardware decode power consumption. Software decode uses 80% more power at 2k resolutions, and 20% more power at 1080p resolutions.

This difference in power consumption is important because hardware acceleration is common for H.264, but not yet for VP9. If websites see VP9 is supported, they may prioritize using it and users will experience an unexplained reduction in battery life.

Bar chart showing extrapolated battery life estimates based on power consumption. When playing back 2k video, software accelerated playback could result in up to four hours less battery life.

Ideally, there would be a way for apps to confirm hardware acceleration itself is supported. Current web specifications don’t allow for this. For this reason, we’ve put VP9 behind an experimental flag in Microsoft Edge, and have provided a default setting for it that automatically enables VP9 when hardware acceleration is detected. VP9 is not supported on Windows mobile SKUs at this time.

Audio codecs, Opus included, don’t have the same power concern and are usually decoded in software. We have, however, elected to put Opus behind an experimental flag as well. Opus is supported on Windows mobile and desktop SKUs.

Managing Experimental Flags

You can manage the settings for VP9 and Opus by navigating to about:flags in the address bar.

Screen capture showing the Media Source Extensions section of the about:flags interface in Microsoft Edge.

Flags may be used to change the default settings for VP9 and Opus. These default settings are:

  • Opus: Enabled
  • VP9: Automatic

The “Automatic” setting for VP9 enables VP9 if hardware acceleration is supported on the device. We did this for the power reason previously discussed as well as the potential on less powerful computers to experience frame drops when doing software decode on higher resolution streams. The full set of VP9 flag settings and their meaning are:

  • Automatic: VP9 is enabled if hardware-accelerated VP9 decoding is supported
  • Enabled: VP9 is always enabled and available for use
  • Disabled: VP9 is always disabled

These settings allow users to have VP9 always enabled or disabled, in addition to our default setting. We encourage experimenting with these settings and look forward to your feedback.

The “Enabled” default setting for Opus means the Opus codec will be enabled and available for website use, and will show up in the MSE MediaSource.isTypeSupported capabilities query. It’s possible to disable Opus using this flag, which would make it unavailable for playback and show as unsupported via isTypeSupported().

VP8 video and Opus audio are important formats for WebRTC support, and have different considerations regarding hardware acceleration. The Edge WebRTC implementation supports VP8 and Opus regardless of the flag settings. See Roadmap update for Real Time Communications in Microsoft Edge for more information.

Integration

VP9 and Opus support can be queried by websites. With VP9 and Opus enabled, the following Media Source Extension capability checks will return “true”:

  • isTypeSupported ('video/webm; codecs="vp9"')
  • isTypeSupported ('video/webm; codecs="vp9, opus"')
  • isTypeSupported ('video/webm; codecs="opus"')
  • isTypeSupported ('audio/webm; codecs="opus"')

And these will return “false”:

  • isTypeSupported ('video/webm')
  • isTypeSupported ('audio/webm')

If VP9 is on “Automatic”, it will show up as supported on systems that have VP9 hardware acceleration, and won’t on systems that don’t.

MediaElement.canPlayType() is used to check capabilities for file-based playback. Edge will respond to any WebM canPlayType() calls with an empty string (the defined response for “not supported”) since we are only supporting WebM on MSE right now.

Microsoft has an ongoing effort to expand codec offerings in Windows. WebM, VP9, and Opus are our latest format additions. We continue to evaluate other formats and look forward to receiving feedback as we work on implementing them.

Please send us your feedback so we can further improve our media support in Microsoft Edge!

– Andy Glass, Principal Program Manager, Silicon, Graphics & Media (VP9 video)
– Neil Hinnant, Program Manager, Silicon, Graphics & Media (Opus audio)
– Jerry Smith, Senior Program Manager, Microsoft Edge (Media)

Map APIs and controls: Adding external elements

In the first post of this series, you got started with the Universal Windows Platform (UWP) MapControl class. In the second post, you worked with geolocation, geocoding, and map routes. In this final post, you are going to make the MapControl your own by customizing it with pushpins and external elements.

Pushpins

Everyone is familiar with the iconic image from TV procedurals of a police detective gazing intently at a wall map covered with pushpins and pieces of colored string connecting all the dots. Sooner or later we all know the detective will figure out where the bad guy / bag of money / ticking time bomb is located simply by staring hard enough. This TV trope is compelling because it is a perfect mirror of how our brains work – human brains constantly evaluate random pieces of visual information in order to find patterns and meaning.

detective board-01

Pushpins in a mapping app are compelling in the same way. They provide you with a tool to draw your user’s attention to interesting visual patterns. In the UWP MapControl, the pushpin analog is called a MapIcon. You can use it just to indicate a “You Are Here” in your app, or to build a symbol legend of interesting nearby attractions, much like a mall directory. To add one to a map, you just need a geopoint and a title.



var pushpin = new MapIcon();

// assign pushpin geoposition
pushpin.Location = new Geopoint(new BasicGeoposition()
{
    Latitude = 51.178840,
    Longitude = -1.826189
});

// assign pushpin title
pushpin.Title = "Here's something interesting!";

//  make sure pushpin always appears
pushpin.CollisionBehaviorDesired = MapElementCollisionBehavior.RemainVisible;
            
// set pushpin bottom center over geoposition
pushpin.NormalizedAnchorPoint = new Point(0.5, 1.0);

// put pushpin on the map
this.myMap.MapElements.Add(pushpin);


Pushpins have a default image that can sometimes be hidden by labels or other elements. You can set the CollisionBehaviorDesired property to RemainVisible in order to prevent this. By default, the top left corner of the image will appear over the MapIcon’s geoposition. You can shift this by giving the NormalizedAnchorPoint x and y values of 0 to 1 (it is set to 0, 0 if unassigned).

2_NormalizedAnchorPoint

While a pushpin, as shown above, can be useful, the MapIcon becomes most interesting when you use it to reveal hidden patterns on a map. For example, how many coffee shops are there in a one-mile radius around your user? Where do UFO sightings tend to cluster in a map of the United States? What is the distribution of medieval castles in the south of France? Each of these patterns tells a story that makes maps, and your app, a source of fascination rather than just something utilitarian.

You can use custom images to replace the default one in order to give you app more personality and to make your maps more relevant. The image must be smaller than 2048 by 2048 pixels.

The pushpin above marks Stonehenge on the Salisbury Plain in England. You can change the MapIcon image using the RandomAccessStreamReference class to point to one of your choosing.



// set pushpin title
pushpin.Title = "Stonehenge";

// add custom Stonehenge image
var myImageUri = new Uri("ms-appx:///Assets/upright.png");
pushpin.Image = RandomAccessStreamReference.CreateFromUri(myImageUri);


3_ancientstonecircles

Connecting the pushpins

The standard TV detective map introduced earlier traditionally has lines between the pushpins that emphasize and draw out patterns. You can do the same thing in the MapControl by using the MapPolyline class. As you might expect, the MapPolyline requires geocoordinates to anchor the polyline. It also allows you to choose the color, thickness, and style of the line. Then, as with the pushpins, you have to add the polyline you create to your map’s MapElements.



// create Stonehenge geoposition
var locStonehenge = new BasicGeoposition()
{
    Latitude = 51.178840,
    Longitude = -1.826189
};

// create Swinside circle geoposition
var locSwinside = new BasicGeoposition()
{
    Latitude = 54.282490,
    Longitude = -3.273860
};

// instantiate mappolyline
var polyline = new MapPolyline();

// add geopsitions to path
polyline.Path = new Geopath(new List<BasicGeoposition>() {locStonehenge, locSwinside});

//set appearance of connector line
polyline.StrokeColor = Colors.OrangeRed;
polyline.StrokeThickness = 2;
polyline.StrokeDashed = true;	

// add to map
this.myMap.MapElements.Add(polyline);


You can go a step further and add multiple locations to the Geopath to create a more evocative set of connectors. In the picture below, all the Neolithic sites are added to the list.

4_neolithicconnectors


Adding shapes to your map

The MapPolygon class lets you add shapes to your map in the same way the MapPolyline class lets you add lines. The difference is mainly that a polygon can have a fill color. For fun, let’s draw a shape roughly in the middle of the three stone circles farthest south.



// instantiate mappolygon
var polygon = new MapPolygon();
            
// set appearance
polygon.StrokeColor = Colors.DeepSkyBlue;
polygon.FillColor = Color.FromArgb(100,255,255,0);
polygon.StrokeThickness = 4;

//create path
polygon.Path = new Geopath(new List<BasicGeoposition>()
{
    new BasicGeoposition() {Latitude=52.5, Longitude=-3.5 },
    new BasicGeoposition() {Latitude=52.5, Longitude=-2.5 },
    new BasicGeoposition() {Latitude=52, Longitude=-2.5 },
    new BasicGeoposition() {Latitude=52, Longitude=-3.5 },
});

// add to map
this.myMap.MapElements.Add(polygon);


What is interesting about the MapPolygon is that you are basically just drawing shapes the way you would with a Cartesian coordinate system. The difference, of course, is that the vertexes in this case can have a global scale stretching hundreds of miles.

5_mappolygon

Adding XAML elements to your map

Finally, you can also treat the MapControl like a sort of canvas and add XAML elements to your map’s Children collection. You then use attached properties to adjust the XAML element once it has been added to the visual hierarchy.



// create new button
var button = new Button();
button.Content = "Push this!";
this.myMap.Children.Add(button);

// assign geoposition
var position = new Geopoint(new BasicGeoposition()
{
    Latitude = 52.25,
    Longitude = -3.0
});
MapControl.SetLocation(button, position);

// center button over geoposition
MapControl.SetNormalizedAnchorPoint(button, new Point(0.5, 0.5));


6_XAMLelements

Don’t use lots of XAML elements if you don’t have to, though. They add some performance overhead, so only use them when you require rich styling or interactivity.

Wrapping Up

The MapControl is an extremely powerful and versatile class. While the earlier posts in this series showed you how to use it in relatively familiar ways, this post went further and showed you how to create a unique mapping app that is specific to your goals, interests, needs of your users.

Having nearly full control of how maps are rendered has even encouraged some developers to use the MapControl for purposes other than actual mapping, such as recreating the map-based board game Risk. One innovative developer even used the Kinect to scan a 3D model of his own head which he could then place anywhere in the world—sort of like a transportable Mount Rushmore.

The UWP MapControl class and location services offer you advanced images of the world to use as a playground. Take advantage of the inherently fascinating character of images of the earth to build mapping apps and beyond. Help people to see things in these maps that they wouldn’t otherwise be able to without you.