ASUS PQ321Q UltraHD Monitor Review: Living with a 31.5-inch 4K Desktop Display

Many consider me to be a 4K hater. The past few trade shows I’ve attended have been pushing it on consumers to replace their TVs, but I see less value in it. When it comes to a computer display, it is a different game. Unlike a 50” TV, we sit close to our monitors, even if they are 30” in size. We also have no worries about a lack of native content, since everything is rendered on the fly and native. There are no issues with the lack of HDMI 2.0, as DisplayPort 1.2 can drive a 3840×2160 screen at 60 Hz.

When it comes to 4K on the desktop, my main question is: how much difference will I see? ASUS is one of the first with a HiDPI display in the PQ321Q. While not truly 4K, it is a 3840×2160 LCD display that can accept an Ultra High Definition (UHD) signal over HDMI and DisplayPort. It also clocks in at a wallet-stretching $3,500 right now. The question is, are we seeing the future with displays here, or are we seeing a niche product?

What does 4K/UHD/HiDPI bring to the desktop? We’ve seen it for a few years now in smartphones and tablets, making their smaller screens more usable for reading and general work. My initial thought is more desktop space, as that is what it has meant before. With a 32” monitor and a pixel density this high, running it without any DPI scaling leads to a desktop where reading text is a huge pain. Instead I believe most users will opt for DPI scaling so elements are larger and easier to read. Now you have something similar to the Retina screen on the iPhone: No more desktop space compared to a 2560×1440 monitor, but one that is razor sharp and easier to look at.

To get to this pixel density, ASUS has relied upon a panel from Sharp that uses IGZO technology. IGZO (Indium gallium zinc oxide) is a material that replaces amorphous silicon for the active layer of an LCD screen. The main benefit is higher electron mobility that allows for faster reacting, smaller pixels. We have seen non-IGZO panels in smartphones with higher pixel densities, but we don’t have any other current desktop LCDs that offer a higher pixel density than this ASUS display. IGZO also allows for a wide viewing angle.

Gateway DX4870-UB2B

The Gateway DX4870-UB2B ($499.99 list) is a basic tower desktop PC that checks all the boxes on what you need from a new desktop, particularly if you already have a LCD display that you’re carrying over. It’s speedy for its segment, has capacious storage, will let your family keep many documents open simultaneously, and it’s relatively inexpensive. Unlike the $300 bargain basement specials, the DX4870-UB2B$499.99 at Best Buy comes with a modern Intel Core i3 processor, dual-band Wi-Fi, and lots of drive space. It’s expandable, so it can grow with your family. It’s not ground breaking, but it’s a solid choice with a great bang for the buck, so it’s our latest Editors’ Choice for budget desktop PCs.

Design and Features
The DX4870-UB2B follows other Gateway desktops, looking almost identical to the last black tower Gateway DX4870-UB17$329.99 at Newegg.com ($500). Like that model, the DX4870-UB2B comes in a tower chassis with black panels all around, including the plastic front panel and metal side panels. The system’s tray-loading DVD burner is hidden, but two of the system’s USB 2.0 ports, SD card reader, and audio jacks are exposed on the top front of the chassis. In the back, the system has four more USB 2.0 ports, two USB 3.0 ports, PS/2 mouse and keyboard ports, HDMI, VGA, Ethernet, more audio jacks, and two connectors for the included WiFi antennas. It would have been nice if the front USB ports were USB 3.0 to accommodate USB hard drives instead of the slower USB 2.0.

The inside of the system is certainly expandable, with plenty of space to move around for future upgrades. The system has space for two additional drives: one optical 5.25-inch bay and one 3.5-inch hard drive bay. Theoretically, you could shoehorn another three to four 2.5-inch notebook class drives in the same space, provided you have the correct brackets to hold the drives. The motherboard has four free SATA ports to service these drives. The system also has two DIMM slots free, along with a slot for a PCIe 3.0 x16 graphics card and two additional PCIe 2.0 x1 expansion cards. One PCIe x1 slot is occupied by the included 802.11a/b/g/n Wi-Fi card, which will serve most users well. This is an improvement over other budget systems like the Lenovo IdeaCentre Q190$416.03 at antonline.com ($400) and Zotac Zbox ID83 Plus$448.99 at Amazon ($473), both of which don’t support 5Ghz WiFi, only the more common and crowded 2.4GHz channels.

The last consideration you have to make for expandability is the system’s 300W power supply. While sufficient for additional drives and minor expansion cards, 300W will be insufficient for a high-powered discrete graphics card with Nvidia’s or AMD’s highest end GPUs. You can of course swap out the included power supply, but most budget system buyers never open their chassis, even if they are tempted by the system’s expandability. Bring a screwdriver if you dare, because you’ll need it for the case door and the drive bays. At least the internal card slots are tool-less.

Like other Gateway systems, the DX4870-UB2B comes with quite a few pre-loaded applications and utilities. These include 7digital, Zinio, Kindle, eBay, Chacha, Netflix, NewsXpresso, Amazon, Tunein, Hulu Plus, Xbox Games, Cut The Rope, Stumbleupon, Skype, Merriam-Webster, Britannica, Spotify, Microsoft Office (ad), Norton Internet Security), and Wild Tangetn games. That’s a lot of pre-loaded apps, and most if not all are available for free from Microsoft Windows Store. While you may want to spend a few moments uninstalling all these programs, fret not, since the system has a capacious 1TB hard drive with plenty of free space left. The DX4870-UB2B comes with a standard one-year warranty.

Performance
The system comes with a third-generation Intel Core i3-3240 processor, 6GB of DDR3 memory, Intel HD Graphics 2500 (integrated in the Core i3 processor), and a 1TB 5,400rpm SATA hard drive. All of these components mean the system is plenty fast on our benchmark tests, certainly faster than the Lenovo Q190 and the Zbox ID83 Plus. That said, there are systems in this price range that are faster, notably the Polywell Nano i3-Q7 ($595) which trades physical and storage space for SSD speed, and the Acer Aspire AT3-600-UR11$449.99 at Newegg.com($600), which has a discrete graphics card and slightly more powerful processor adding to its performance totals. Check the performance chart link to see the final numbers, but suffice to say the DX4870-UB2B has the performance to keep your family happy for the next five years or so.

HP Series 800 G1 Generate EliteOne Sharp graphics

JAKARTA – HP EliteOne 800 Series G1 and Series 800 G1 is a device EliteDesk AiO HP commercial desktop PCs and most resilient form factor with the widest selection, which was created specifically to meet the demands of today’s business.
HP desktop series EliteDesk / EliteOne 800 G1 is supported by the 4th generation Intel ® Core ™ processors for maximum performance and the graphics are sharp, and the new caching option and a solid state drive that provides fast access to data and applications.
AiO devices and desktop PCs supported by HP Elite features enterprise-class security and client management solutions to protect and manage critical business data, device and user identity with Intel vPro support.
With the highest efficiency class power supply that is up to 94 percent, Total Cost of Ownership (TCO) offered by this device was not in doubt.
EliteOne HP AiO PC 800 G1 is the most powerful, rich multimedia, with a stylish design which is 23 percent thinner than the previous generation and support for Windows ® 8 with a dynamic touch screen experience, and highly interactive interface.
HP EliteDesk / 800 series G1 EliteOne provide robust and reliable performance with deployment options that can be tailored to the needs of the organization, all backed by a comprehensive portfolio management and security solutions from HP. (Eko Sutriyanto)

Lenovo IdeaCentre A520 Touch, slim AIO PC

Jakarta, (ANTARA News) – IdeaCentre A520 Touch will soon become a mainstay of Lenovo Indonesia to dominate the market “all-in-one (AIO) desktop PC” in Indonesia with a sleek design and space-saving and very flexible angle capability.

Products launched in Jakarta on Tuesday afternoon it has the same appearance as its predecessor product, the IdeaCentre A720 Touch, which won many awards. What distinguishes the IdeaCentre A520 IdeaCentre A720 Touch Touch is a 23-inch full HD screen without a frame.

IdeaCentre A520 Touch that supports the “10-point multi-touch” screen that has a wide angle that can be adjusted, from minus five degrees to 90 degrees, and IPS LED with a picture perfect view from any angle.

Flexibility IdeaCentre A520 Touch screen allows users to watch movies, play touch-based games or enjoy video chat in any position.

IdeaCentre A520 Touch also comes with an Intel Core i5 processor up to the third generation of the Intel HD Graphics 4000 and 4 Gigabyte DDR3 memory.

The products also have additional features such as Dolby certified speakers with Dolby Home Theater v4, various multimedia applications and games that are optimized for the touch screen.

In addition Touch IdeaCentre A520, Lenovo IdeaCentre B540 Indonesia also launched Touch, a home entertainment center with a 23-inch screen, and the IdeaCentre C540 Touch an affordable and efficient place to use at home.

Monitor Your CPU With A Real Tachometer

Whether you’re a tinkerer with a custom rig, or you just aren’t sure why your computer’s fans are running, checking your CPU usage is a pretty common task. Instead of using a boring on-screen activity monitor though, you can hook up your machine to a car tachometer for constant feedback.

This hack comes courtesy of ivancreations, who created an entire PC monitoring block from real-world components. The full instructions are on his blog and needless to say, they’re pretty complicated. If you can makes heads and tails of his plans though, the results speak for themselves.

While the tachometer is my favourite part of the build, he also wired up some LED light grids to illustrate other vital system information as well. If you think you’re up to it, or just want a closer look, be sure to check out the source link.

Creating a 3D Game With Three.js and WebGL

Prerequisites

  • A browser with WebGL – this game has been tested on Chrome and Firefox. IE still doesn’t support WebGL, unless you’re using Windows 8.1 with IE11.
  • Three.js library available for download from the Three.js website
  • The Keyboard.js helper library I used for this project, created by Arthur Schreiber at No Karma. Download it from my GitHub repository
  • A basic understanding of what Three.js does. Read this super simple, super quick tutorial by Paul Lewis. It’s basically a short-hand version of this article.

Setup

Get a base index.html running

Step one when making a web-based game is to create the host index.html file. In our case, it only needs to be a very simple set of elements, so we can bundle the CSS styling too.

Import Keyboard.js and Three.js

Three.js is a library contained in just one JavaScript file, so we can grab the minified version from the website.

For Keyboard input, we will need to referencethe aforementioned JavaScript file in our index.html as well.

Create setup() and draw() functions

The setup() function will be the start point for the game code. The draw() function will be run every frame and will handle all the rendering and game logic.

In order to loop the draw() function, we simply utilise the requestAnimationFrame() function call, and pass ‘draw’ as the parameter. Remember, not all browsers natively support the call, and you might have to use Paul Irish’s shim to gain maximum compatibility. Also, it is important to realise that requestAnimationFrame() does not guarantee a fixed frame-rate, so you need to use time-deltas to calculate realistic physics. For a basic game like Pong, we don’t really care about that.

Basic World

Set up the Three.js world and camera

Three.js includes these important elements:

  • Scene
  • Renderer
  • Camera
  • Mesh
  • Light
  • Material

Cameras, Meshes, and Lights need to be added to the scene using the scene.add() function.

Attach a WebGL Three.js Renderer to the DIV

The renderer is attached to whichever HTML DOM element you wish to render the scene to, and a render() call is made each frame to the renderer in order to draw the Three.js scene.

Add a camera to the scene

Three.js has the option to create Perspective and Orthographic cameras. For most uses, Perspective camera is the best choice. We can change position and rotation information of the camera like any other object in the scene.

Draw a sphere and light it

Meshes must be paired with Materials in order to give them a defined look and feel. Meshes can be of many types, include primitives such as Cube, Sphere, Plane and Torus. Materials can have different characteristics depending on their type. The basic Material types include Lambert, Phong, and Basic.

  • Basic renders an unlit Mesh with no shadows or dark shading. A sphere will look like a circle if rendered with Basic.
  • Lambert is a simple diffuse-like lighting that creates shading on sides facing away from a light source. It gives a basic 3D look of surfaces that are matte (non-shiny and non-reflective)
  • Phong is used for achieving a plastic-like look and feel, with the ability to gain highlights that give a much shinier appearance to the Mesh.

Show off your sphere with a Point Light. This is the most basic light, with no direction or rotation. Make sure you tweak the light’s intensity and distance to get it looking good.

Add Game Objects

Draw playing area plane

The playing area will be a Three.js Mesh object of type Plane. Make sure the plane matches the play area, giving a small buffer gap to indicate where the paddles can and can’t go.

Draw paddles

The paddles will be Mesh objects of type Cube. Position each of the paddles on opposite sides of the play area.

1234567891011121314151617181920212223242526272829303132333435363738394041
// set up the paddle vars
paddleWidth = 10;
paddleHeight = 30;
paddleDepth = 10;
paddleQuality = 1;
// set up paddle 1
paddle1 = new THREE.Mesh(
new THREE.CubeGeometry(
paddleWidth,
paddleHeight,
paddleDepth,
paddleQuality,
paddleQuality,
paddleQuality),
paddle1Material);
// add the paddle to the scene
scene.add(paddle1);
// Set up the second paddle
paddle2 = new THREE.Mesh(
new THREE.CubeGeometry(
paddleWidth,
paddleHeight,
paddleDepth,
paddleQuality,
paddleQuality,
paddleQuality),
paddle2Material);
// Add the second paddle to the scene
scene.add(paddle2);
// set paddles on each side of the table
paddle1.position.x = -fieldWidth/2 + paddleWidth;
paddle2.position.x = fieldWidth/2 – paddleWidth;
// lift paddles over playing surface
paddle1.position.z = paddleDepth;
paddle2.position.z = paddleDepth;
view rawBNG_Pong_paddlecreateThis Gist brought to you by GitHub.

If you manipulate the camera positions, as seen in the screenshot, you can give a different perspective to the player.

Basic Logic

Ball movement

The ball will have an X-direction and a Y-direction that determines the movement per frame.

// ball’s x-direction, y-direction and speed per frame
var ballDirX = 1, ballDirY = 1, ballSpeed = 2;

The ball will move at a constant speed in the X-plane every frame. To this end, we will specify a ballSpeed variable that acts as a multiplier for the direction values.

// update ball position over time
ball.position.x += ballDirX * ballSpeed;
ball.position.y += ballDirY * ballSpeed;

We want the ball to have some unpredictable characteristics (e.g. when it gets sliced quite hard) so we will allow the Y-direction to go up to a maximum of ballSpeed * 2. You can tweak the values until you’re happy with how the ball behaves.

// limit ball’s y-speed to 2x the x-speed
// this is so the ball doesn’t speed from left to right super fast
// keeps game playable for humans
if (ballDirY > ballSpeed * 2)
{
ballDirY = ballSpeed * 2;
}
else if (ballDirY < -ballSpeed * 2)
{
ballDirY = -ballSpeed * 2;
}

Ball wall bounce logic

Simple collision detection logic is required to check if the ball is touching each of the side ‘walls’. Using a series of ‘if-else’ statements, we check the ball positions against the predetermined wall positions. In the case of a collision, we simply switch the Y-direction of the ball, creating a bounce effect.

// if ball goes off the top side (side of table)
if (ball.position.y <= -fieldHeight/2)
{
ballDirY = -ballDirY;
}
// if ball goes off the bottom side (side of table)
if (ball.position.y >= fieldHeight/2)
{
ballDirY = -ballDirY;
}

Later, we will edit some of this code in order to implement scoring when the ball passes a paddle.

Keyboard input for paddles

We will utilise a very effective short-cut in order to easily get keyboard input working in this game. Using the Keyboard.js file provided, we simply have to include the reference to it in the index.html file and we are set. Only one function call is required, the Key.isDown() call. Given a parameter, the library checks if that particular key is current being pressed, and returns a boolean value.

// move left
if (Key.isDown(Key.A))
{
// code to move paddle left
}

We use the ‘A’ and ‘D’ keys to move the paddle left and right, but you can edit the Keyboard.js with additional values if you want to use your own control scheme.

var Key = {
_pressed: {},
A: 65,
W: 87,
D: 68,
S: 83,
// add your required key code (ASCII) along with the name here
// for example:
SPACE: 32,
};

While dealing with keyboard input, it is also important to ensure that the input is never blindly updated in game. We have to check that the paddle isn’t made to move off the play area, and we do that with some ‘if-else’ statements as well.

// move left
if (Key.isDown(Key.A))
{
// if paddle is not touching the side of table
// we move
if (paddle1.position.y < fieldHeight * 0.45)
{
paddle1DirY = paddleSpeed * 0.5;
}
// else we don’t move and stretch the paddle
// to indicate we can’t move
else
{
paddle1DirY = 0;
paddle1.scale.z += (10 – paddle1.scale.z) * 0.2;
}
}

Note that we use a paddle direction variable, rather than simply applying a change to the position values. This will come in handy when programming the ball to ‘slice’ when hit at an angle with a fast-moving paddle.

Opponent logic

When you code a game of this calibre, it is of utmost importance that you create a vivid, lush environment with a host of emotional, highly-relatable characters that showcase this generation’s strides forward in technology. Instead, we will code a Pong A.I. that blindly follows the ball, because that is even better.

We can update the opponent difficulty by using a variable instead of introducing magic numbers. This variable will affect the ‘reaction rate’ of the opponent by increasing the Lerp (Linear-Interpolation) time.

When using a Lerp (Linear-Interpolation) function, we must ensure the opponent plays fairly by limiting their maximum travel speed. We do that with a few more if-else statements.

// in case the Lerp function produces a value above max paddle speed, we clamp it
if (Math.abs(paddle2DirY) <= paddleSpeed)
{
paddle2.position.y += paddle2DirY;
}
// if the lerp value is too high, we have to limit speed to paddleSpeed
else
{
// if paddle is lerping in +ve direction
if (paddle2DirY > paddleSpeed)
{
paddle2.position.y += paddleSpeed;
}
// if paddle is lerping in -ve direction
else if (paddle2DirY < -paddleSpeed)
{
paddle2.position.y -= paddleSpeed;
}
}
If want to extend immersion, you could also using the paddle.scale property to stretch the paddle when it can’t be moved. This indicates an issue to the player which they can then address immediately. In order to accomplish this, we must ensure the paddle always Lerps back to the default scale size.
// We lerp the scale back to 1
// this is done because we stretch the paddle at some points
// stretching is done when paddle touches side of table and when paddle hits ball
// by doing this here, we ensure paddle always comes back to default size
paddle2.scale.y += (1 – paddle2.scale.y) * 0.2;

Adding Gameplay

Making the ball reset after missing a paddle

To get the main scoring gameplay working, we need to first remove the ball’s ability to bonce off the paddle-facing walls. To do this, we remove the bounce code from the two corresponding if-else statements.

// if ball goes off the top side (side of table)
if (ball.position.y <= -fieldHeight/2)
{
ballDirY = -ballDirY;
}
// if ball goes off the bottom side (side of table)
if (ball.position.y >= fieldHeight/2)
{
ballDirY = -ballDirY;
}
//// ——————————— ////
CHANGED CODE
//// ——————————— ////
// if ball goes off the ‘left’ side (Player’s side)
if (ball.position.x <= -fieldWidth/2)
{
// CPU scores a point
// update scoreboard
// and reset ball
}
// if ball goes off the ‘right’ side (CPU’s side)
if (ball.position.x >= fieldWidth/2)
{
// player scores a point
// update scoreboard
// and reset ball
}

We can handle scoring in many different ways. For a simple game like this, we can simply increment the corresponding score count variable.

// if ball goes off the ‘left’ side (Player’s side)
if (ball.position.x <= -fieldWidth/2)
{
// CPU scores
score2++;
// update scoreboard HTML
document.getElementById(“scores”).innerHTML = score1 + “-” + score2;
// reset ball to center
resetBall(2);
// check if match over (someone scored maxScore points)
matchScoreCheck();
}

We can then update the HUD element in the DOM by setting its innerHTML value. Finally, we have to reset the ball once someone has scored. A simple function can be written to reset the ball, with a parameter indicating which paddle just lost (so we know which paddle to send the ball to next time).

// resets the ball’s position to the centre of the play area
// also sets the ball direction speed towards the last point winner
function resetBall(loser)
{
// position the ball in the center of the table
ball.position.x = 0;
ball.position.y = 0;
// if player lost the last point, we send the ball to opponent
if (loser == 1)
{
ballDirX = -1;
}
// else if opponent lost, we send ball to player
else
{
ballDirX = 1;
}
// set the ball to move +ve in y plane (towards left from the camera)
ballDirY = 1;
}

Making the ball bounce off paddles

Alright, this is it. The big one. Literally the biggest feature of this game. It’s time to get the paddles hitting the ball. In a simple Pong game, paddle-ball physics are nothing more than a couple of if-else statements. We check the X-position and Y-position of the ball against the paddle’s rectangular bounds, and if they intersect, we bounce the ball away.

// if ball is aligned with paddle1 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle1.position.x + paddleWidth
&& ball.position.x >= paddle1.position.x)
{
// and if ball is aligned with paddle1 on y plane
if (ball.position.y <= paddle1.position.y + paddleHeight/2
&& ball.position.y >= paddle1.position.y – paddleHeight/2)
{
// ball is intersecting with the front half of the paddle
}
}

It’s also important to check the direction of the ball’s travel, as we only want to check collisions in one direction (the direction towards the opponent.)

// and if ball is travelling towards player (-ve direction)
if (ballDirX < 0)
{
// stretch the paddle to indicate a hit
paddle1.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle1DirY * 0.7;
}

We will also affect the ball’s lateral movement depending on the relative speed of the paddle when hitting the ball. This is particularly useful in introducing the biggest variable in Pong: the slice. Slicing the ball is often the only way to confuse and outmaneuver the opponent, so it is vital in this game.

Remember to duplicate the code, but update the values to match the opponent’s paddle. You can use this opportunity to gimp your opponent’s ability somewhat, by reducing the hitbox size or decreasing the slice amount. It’s what we would all do.

Here is the final paddle-ball collision function:

// Handles paddle collision logic
function paddlePhysics()
{
// PLAYER PADDLE LOGIC
// if ball is aligned with paddle1 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle1.position.x + paddleWidth
&& ball.position.x >= paddle1.position.x)
{
// and if ball is aligned with paddle1 on y plane
if (ball.position.y <= paddle1.position.y + paddleHeight/2
&& ball.position.y >= paddle1.position.y – paddleHeight/2)
{
// and if ball is travelling towards player (-ve direction)
if (ballDirX < 0)
{
// stretch the paddle to indicate a hit
paddle1.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle1DirY * 0.7;
}
}
}
// OPPONENT PADDLE LOGIC
// if ball is aligned with paddle2 on x plane
// remember the position is the CENTER of the object
// we only check between the front and the middle of the paddle (one-way collision)
if (ball.position.x <= paddle2.position.x + paddleWidth
&& ball.position.x >= paddle2.position.x)
{
// and if ball is aligned with paddle2 on y plane
if (ball.position.y <= paddle2.position.y + paddleHeight/2
&& ball.position.y >= paddle2.position.y – paddleHeight/2)
{
// and if ball is travelling towards opponent (+ve direction)
if (ballDirX > 0)
{
// stretch the paddle to indicate a hit
paddle2.scale.y = 15;
// switch direction of ball travel to create bounce
ballDirX = -ballDirX;
// we impact ball angle when hitting it
// this is not realistic physics, just spices up the gameplay
// allows you to ‘slice’ the ball to beat the opponent
ballDirY -= paddle2DirY * 0.7;
}
}
}
}
view rawBNG_Pong_paddlecollCompleteThis Gist brought to you by GitHub.

Scoring

In Pong, it is usually simplest to have a maximum score value, such that a game is won when either player reaches that score. To that end, we can easily create a maxScore variable and set it at the start of the match.

We then create a function to check if either player has scored equal or higher than the maximum. This function should be called only when a score has been changed (i.e. when someone scores a point.)

// checks if either player or opponent has reached 7 points
function matchScoreCheck()
{
// if player has 7 points
if (score1 >= maxScore)
{
// stop the ball
ballSpeed = 0;
// write to the banner
document.getElementById(“scores”).innerHTML = “Player wins!”;
document.getElementById(“winnerBoard”).innerHTML = “Refresh to play again”;
}
// else if opponent has 7 points
else if (score2 >= maxScore)
{
// stop the ball
ballSpeed = 0;
// write to the banner
document.getElementById(“scores”).innerHTML = “CPU wins!”;
document.getElementById(“winnerBoard”).innerHTML = “Refresh to play again”;
}
}

After a match is deemed complete, it is simplest to just return the ball to the centre and stop any movement, so that play doesnt inadvertently continue.

Prettifying the Game

HUD

It’s important to give feedback to the player so they know what’s going on. For Pong, the least we can do is keep a scoreboard ticking over. Instead of trying to draw the HUD on the same layer as the game, we can use the other DOM elements to provide the required feedback.

It’s also good to indicate the maximum score as well, so we have another element for that which we will update at match start.

// update the board to reflect the max score for match win
document.getElementById(“winnerBoard”).innerHTML = “First to ” + maxScore + ” wins!”;

Shadows

Finally, it is time to make things look a tad more polished. Three.js has the awesome ability to create shadows for primitive objects (Cube, Plane, Sphere, etc.) so we can utilise that to make the game look nicer.

Shadows can’t be created with just a Point light, so we have to add a DirectionalLight or a SpotLight. A SpotLight shines a circular beam of light onto surfaces, which DirectionalLight simply shines a light in a certain direction with no regard to positioning.

We will use a SpotLight because it clearly indicates where the light originates from and shines towards.

We can update the SpotLight to follow the ball around to give a more dynamic look and feel to the game, whilst showcasing the hard work we just put into the lighting.

// we can easily notice shadows if we dynamically move lights during the game
spotLight.position.x = ball.position.x;
spotLight.position.y = ball.position.y;

To make an object in the scene cast or receive shadows, we simply set their .receiveShadow and .castShadow variables to true. For example,

paddle1 = new THREE.Mesh(
new THREE.CubeGeometry(paddleWidth, paddleHeight, paddleDepth, paddleQuality, paddleQuality, paddleQuality),
paddle1Material);
// add the sphere to the scene
scene.add(paddle1);
paddle1.receiveShadow = true;
paddle1.castShadow = true;

Conclusion

This is but a basic introduction to the power of Three.js, which should allow you to create a basic Pong clone.

Play the latest build of this game here: LATEST BUILD*

Find the latest code at its GitHub page*

You can still do quite a number of things to polish your game, such as

  • Create animations for the paddles and ball
  • Update the HUD to look prettier
  • Import complex objects created in Modeling packages, to design a more immersive environment
  • Move HUD elements inside the game view to allow for full-screen gaming
  • Mess around with complex shaders to create reflections and other cool effects

Microsoft readies IE 11 for Windows 7, too

Browser aficionados and haters alike will be overjoyed that Microsoft is keeping its promise to keep the new Internet Explorer up-to-date on Windows 7 as well as Windows 8.

The Internet Explorer 11 Developer’s Preview for Windows 7, which debuted on Thursday, introduces the most of the new features and functionality of the Windows 8.1 default browser.

Roger Capriotti, Microsoft’s marketing director for Internet Explorer, said that, like IE 10 forWindows 7, IE 11 won’t have the modern interface, but it will have performance benefits.

“We’re faster than the folks at Chrome or the folks at Firefox,” he said. “We’ve got better CPU [processing times], better usage, and better load time overall.”

In addition to usual pitch of improved overall performance, the specifics of the Windows 7 IE 11 Developer’s Preview include updated standards support and overhauled developer tools.

Repeating a talking point that’s been at the forefront of Microsoft’s campaign to revitalize its previously-moribund browser, Capriotti said that the team building IE wants developers “to spend more time developing and less time on standards.”

Most of the backend changes to IE 11 for Windows 7 are in the Windows 8.1 version. These include several firsts that result in faster site loading, according to Microsoft.

The browser is the first to implement the W3C Resource Priorities standard, so that developers can tell the browser which parts of a page to load first; it’s the first to render text on the graphics processing unit (GPU), to more directly accelerate page loading; and it’s the first to natively decodes JPG images in real-time on the GPU; which reduces overall battery drain as well as speeds up site loading.

IE 11 also includes support for WebGL, and it supports the security- and speed-focused SPDY protocol, which originated at Google. These are notable because both previously had been sniffed at by Microsoft. The ECMAScript 6 standard scripting language is supported, too, as is more “just-in-time” compiler in the browser’s JavaScript engine, Chakra.

And to get developers to stand up and take notice, the Microsoft team has overhauled its “F12” developer tools. There’s a new memory management tool that shows in cleanly-designed, real-time charts memory spikes and other problems.

This interface responsiveness report is good news for developers using IE11, but most people will notice changes under the hood: WebGL and SPDY support, for better graphics and faster page-loading, respectively.

(Credit: Microsoft-News.com)

A new emulation tool allows the developer to mimic how their site will look on screen sizes for different devices. It also has a geolocation tool for region-specific debugging.

The new User Interface Responsiveness tool isn’t not working in the current developer’s preview, but Capriotti says it will ship in the final version. It uses more graphics than before to show developers how a site is behaving, with color-coded problems areas and detailed, real-time charts.

To sweeten the deal, the company has revamped its debugging modern.IE Web site, offered a 25 percent discount on Parallels Desktop 8 for Mac, and made virtual machines available for Internet Explorer 11.

Basically, Internet Explorer 11 is a highly competitive browser. Or at least, that’s Microsoft’s plan. But the competition updates on a six-week release cycle, and Capriotti wouldn’t say when IE 11 would be ready for the public. If it follows the release pattern of IE 10 for Windows 7, it will be around four months after IE 11 arrives with Windows 8.1.

Besides swimming upstream against years of negative marks for IE, Microsoft struggles with rapid standards implementation. Part of that is market dynamics. According to NetApplications’ market share statistics, IE still has more people using it than Chrome and Firefox combined, and making changes on a six-week release cycle as Google and Mozilla do would likely anger customers.

However, that means that those browsers, which are developed in a far more open manner than IE, are able to implement new technologies and standards much more rapidly than IE. Capriotti wouldn’t confirm any IE development on the latest in browser tech such as ASM.js, which Firefox has and Chrome is looking at adopting; or WebRTC, an HTML5-based real-time communications protocol that eliminates the need for plug-ins like Skype.

“There’s this tension of what rapid release should be,” he said. “Is it 6 weeks? Six months? We don’t think it should be six years,” he joked.

The truth is that all of Microsoft’s Windows divisions are moving towards updating more rapidly than in the past, as Steve Ballmer said at the recent Build conference, and that includes Internet Explorer.

But while Microsoft is concerned with keeping Internet Explorer up with the Joneses, the Joneses — mostly Chrome and even Firefox a bit as it moves into the mobile OS world — are looking beyond the traditional markets.

Talk Nokia Lumia Excellence 1020

HELSINKI – 41 megapixel camera is a major advantage presented by Lumia 1020. But Nokia claims that there are many other advantages to selling this smartphone.

Head of Marketing and Sales of Nokia in North America Matt Rothschild, said the camera is not the only advantage Lumia 1020. Hardware elements, including the AMOLED screen to accessories Camera Grip and shutter button, says Rothschild, a smartphone is another advantage.

“On the whole, this is what we refer to as the volume of product.’s (Lumia 1020) is very beautiful to grip, has a good balance, and well designed.’s What we call a consideration” Rothschild said, as quoted from Venture Beat, Monday (15/07/2013).

As for the camera, said Rothschild, Lumia 1020 has a very broad target audience, ranging from the professional to make photography only as a hobby.

“But the most important thing for us is that when we talk to customers, they tell us that they want to have a good picture. Everyone knows that smartphones now include photographic device that can be carried anywhere, so this is the core thing that all people are looking for,” he concluded.

Logitech Mouse M235 sold Rp 190 Thousand

JAKARTA – Not only unique, Logitech ® Wireless Mouse M235 Limited Edition is fairly advanced. Because the mouse has been equipped with a Logitech ® Advanced Optical Tracking that can work in almost any kind of surface.
Connectivity Logitech Advanced 2.4 GHz wireless gives you the freedom to faster data transmission and no lag or connection is lost.
This advanced wireless mouse connected via nano-receiver is so small sturdy nan, you simply connect it to the USB port and then forget about it. Product contoured and comfortable in the hand, with rubber grip and scroll whell to scroll naturally.
Logitech ® Wireless Mouse M235 is equipped with On / Off button and an intelligent sleep mode, to help you to conserve battery power, so the battery can last up to 1 year, depending on usage patterns and computing conditions.
Logitech ® Wireless Mouse M235 Limited Edition has been available in the Indonesian market with a retail price of USD 19.99 or approximately USD 190 thousand.

Upland Software Hires Brian Wilson as Vice President of Sales

AUSTIN, Texas, July 11, 2013 /PRNewswire/ — Upland Software, the world’s largest cloud provider of enterprise software for project, portfolio, and work management, today announced that Brian Wilson has joined the company as Vice President of Sales. In this role, he will direct Upland’s global field and inside sales force in aligning clients’ business goals with Upland’s family of best-of-breed applications.

Brian comes to Upland with over twelve years of enterprise technology sales experience. Most recently, he was a Vice President of Sales at Innotas, a cloud provider of project and portfolio management (PPM) software.

“Brian’s experience in the cloud PPM space, proven sales management track record, and focus on a consultative, customer-centric approach will be tremendous assets in helping us achieve our organic growth goals,” commented Ludwig Melik, President of Upland Software. “We are thrilled to have him on the team. One of the exciting aspects of the Upland vision is that it allows us to attract top talent, drawn by the opportunities and challenges of creating the first cloud project, portfolio, and work management provider with real scale.”

Upland’s strategy is to build a family of cloud products that address a comprehensive range of PPM needs from strategic planning to work execution, whether in IT or across the business, managing projects or ad hoc work, or focused on “top-down” portfolio analysis or “bottom-up” productivity. Cloud software has transformed the market with its rapid speed-to-value, scalability, low total cost of ownership, and reduced financial risk, as well as its inherent ability to deliver a real-time data integration and collaboration platform to distributed workforces on a local or global scale. Bringing together strong, established cloud products not only creates economies of scale, but also opportunities to leverage talent, product innovation, and best practices across the Upland family of applications.

“What drew me to Upland are the convictions we share about the transformative potential of project, portfolio, and work management as a business discipline; the power of a cloud delivery model; and the integral role of the sales process in laying the foundations for long-term customer success,” Brian Wilson explained.  “I am also excited to work with such a seasoned, talented sales team. It’s great to be on board.”

Prior to Innotas, Brian held various sales and management positions at Seagate Technology and Fujitsu Computer Products. He holds a Bachelor’s degree from the University of California, Davis in Communication with a minor in Managerial Economics.

About Upland Software

Upland is the world’s largest cloud provider of enterprise software for project, portfolio and work management. Upland is the only cloud software provider that offers a comprehensive family of applications that enable organizations to align their goals, projects and programs, optimize their resource utilization and workflows, and empower teams to collaborate and work effectively.