Planet Gamedev

Gamasutra Feature Articles

Get a job: Google is looking for a mobile and VR Graphics Engineer

November 24, 2015 11:13 PM

Google is looking for a graphics engineer to work on "high quality, interactive, animated short stories" delivered via its Google Spotlight Stories platform to smartphones and VR devices from Cardboard to Rift. ...

Don't miss: The genre blender - Experiments in multigenre multiplayer

November 24, 2015 11:05 PM

A team at Carnegie Mellon's Entertainment Technology Center launched a project to determine how to get multiple game genres -- racing, first person shooter, and puzzle -- to blend into one socially competitive experience. ...

Video: League of Legends - Building an eSport

November 24, 2015 07:53 PM

How do you design a game to be competitively rigorous, strategically diverse, skill-based, entertaining to play, and exciting to watch? Riot's Ryan Scott and Frank Lantz discuss nurturing League of Legends into an eSport. ...

Game From Scratch

2D Game Art with Krita Tutorial Kickstarter Campaign

by at November 24, 2015 07:40 PM


I don’t often announce Kickstarter campaigns unless they are specifically about the creation of game development tools but for this one I am making an exception as this project looks high quality, is game developer focused and Krita itself deserves a great deal more exposure.  The campaign is called Create Professional 2D Game Art: Krita Video Training and it walks the user through the process of creating 2D art using Krita, a completely free cross platform 2D painting tool.  Depending on the level of success with the campaign it will result in tutorials on side view painted style art, isometric view cel shaded art and top down pixel style art if all goals are met.  The ultimate outcome will create a course hosted on Udemy.


At the end of the day, there really aren’t a ton of 2D art tutorials available, I can personally only think of a handful, most of which I linked in my getting started in game art guide.  There are even less focusing around using Krita itself.  Finally, I like the guys art style, so I would like to see this go somewhere.


Anyways, here is the Kickstarter pitch video.  If you are looking for 2D art instruction, check it out.

Geeks3D Forums

AMD Radeon Software Crimson Edition Beta 15.300

November 24, 2015 07:32 PM

Download from support page

Still no GLSL 4.50
OpenCL GPU acceleration disappeared on my legacy APU


Gamasutra Feature Articles

No Dead or Alive Xtreme 3 for the West, says publisher

November 24, 2015 07:04 PM

The notorious cheesecake sports game series won't have its third installment sold in the West, according to a Koei Tecmo rep, thanks to "issues" with the representation of women. ...

Blog: How we can level-up our game audio

November 24, 2015 06:29 PM

"This weekend, I had the pleasure of attending the Electronic Music Midwest Festival... it gave me the opportunity to think about how elements in other music and sound design genres can really level up our game audio chops." ...

Get inside the minds of Tom Clancy's The Division NPCs at GDC 2016

November 24, 2015 05:47 PM

GDC officials highlight a fresh pair of great GDC 2016 talks from the designers of Tom Clancy's The Division and a potent advocate for accessibility in game design. ...

A process for hiring the right people

November 24, 2015 05:10 PM

"I want you to think about what your goals are for hiring as well as what message you want to send to the candidate throughout the interview process. Then, craft your process to achieve those goals." ...

Game From Scratch

Free Construct 2 Book “Level Zero”

by at November 24, 2015 04:32 PM


Over on the Construct2 blog there is this announcement of a new free e-book Level Zero about programming games from scratch using Construct2.


This recently published book "Level 0" is a resource designed for the absolute beginner. You'll learn how to set up characters and backgrounds, apply in-game mechanics and implement if – then functions and end up with five fully functional mini-games. The book will also show you how to publish your games to app stores and make them available to millions of potential customers around the world. The goal of Level 0 is to give aspiring game developers the basic building blocks to apply their creativity and bring their vision to life. For example, one of the mini-games you’ll learn to build is a simple sound board app where you click on an image and the corresponding sound will play. Through this exercise, not only do you pick up the skills to build a virtual keyboard or maybe an educational app that teaches kids the sounds farm animals make but also learn how to use sound, music and touch functions that can be used for subsequent arcade and action games. Each of the 5 mini-games covered in the book has already been used by thousands of Construct 2 users to build their first game on Construct 2.

This book uses Construct 2 in all the featured tutorials. According to the authors,"Construct 2 is as easy as it gets for making a game". Spot on!

C'mon, gimme the download link!

It's available on for a little over $3 USD, however we've managed to get permission to distribute it for free on Scirra for now!

Download for Free

(Right click and "Save Link As")

And good news, Ankur tells us that there's a second book in development detailing how to build 3 classic arcade games. Keep your eye out!


So head on over to the Scirra blog to download a free copy, or support the authors by purchasing it on Amazon.

Unity Release Patch 4.6.9p3

by at November 24, 2015 04:24 PM


Unity have just released patch 4.6.9p3 for Unity 5.2.  From the patch

As always, patch releases are recommended only for users affected by those bugs fixed in that patch.

  • Android: Added support for Marshmallow runtime permissions.
  • Android: Audio - Disabled Fast Path for GearVR.
  • (734408) - Android: Fixed OBB deployment on Android 6.0 and some older devices.
  • (738356) - iOS/IL2CPP: Now allow the [Preserve] attribute to correctly prevent stripping of a method in a nested type.
  • (735880) - iOS/IL2CPP: Enabled profiling of GC allocations.
  • (738232) - iOS/IL2CPP: Fixed race condition during cleanup of thread pool threads.
  • (737996) - iOS/IL2CPP: Prevent generated C++ code from including a header file that was not generated when the type which could have been generated in that header is used only in an attribute applied to an assembly.
  • (733799) - iOS/IL2CPP: Set default stack size to 1MB to match Mono behavior.
  • (737503) - iOS: Fixed CRC check when using WWW.LoadFromCacheOrDownload(url, fileVersion, crc).
  • (687059) - UI: Fixed issue that caused FontUpdateTracker to add an additinal RebuildForFont handler whenever a Text component was enabled using a font with no other active Text components using that font.

You can download the patch for Windows here and MacOS here.

Gamasutra Feature Articles

Fans can back - and profit from - crowdfunded games in U.S. next month

November 24, 2015 03:53 PM

Thanks to new rules adopted by the Securities and Exchange Commission, the next campaign on video game crowdfunding platform Fig will let U.S. fans invest in a game and get a cut of any potential profits. ...

Recreating a video game from 1958: Tennis For Two's conservation story

November 24, 2015 03:25 PM

"One of the most fun projects I had the opportunity to work on this year was a recreation of the 1958 video game Tennis For Two, which is fully playable and installed in the New York Historical Society." ...

Standalone Wii U GamePads go on sale in Japan

November 24, 2015 03:07 PM

Nintendo has finally started selling standalone Wii U GamePads, although they're only available in Japan for the time being. ...

Game From Scratch

The GIMP Turns 20 with Release 2.8.16

by at November 24, 2015 02:03 PM


It’s hard to believe that GIMP (General Image Manipulation Program) has now been around for 20 years.  To go along with the 20th anniversary, they also released version 2.8.16.  The following from the GIMPrelease announcement:


New Releases and The Future

To celebrate the 20th anniversary, we released an update of the current stable version of GIMP. Newly released GIMP 2.8.16 features support for layer groups in OpenRaster files, fixes for layer groups support in PSD, various user interface improvements, OSX build system fixes, translation updates, and more changes.

Our immediate future plans are to release first public version in the unstable 2.9.x series that will feature fully functional GEGL port, 16/32bit per channel processing, basic OpenEXR support, vastly improved color management implementation, new tools, on-canvas preview for many filters, and more. This release will encompass over three years of work and become the first milestone towards 2.10.

Following v2.10 release, we shall complete the GTK+3 port that is required to bring back state of the art Wacom support for Windows users. When it’s done and GIMP 3.0 is out, we shall finally be able to get started on some very exciting and much anticipated features like non-destructive editing. Please refer to Roadmap for more details.


Well then, happy birthday GIMP.  Head on over here to download it now.

Gamasutra Feature Articles

Some tips for hiring audio contract work

November 24, 2015 12:02 PM

"I would like to share some insights in the hope that they might save time and make similar searches easier for others. Some might apply to general contract work hiring, while others are specific of musicians and audio designers." ...

Blog: In defense of personal projects

November 24, 2015 09:00 AM

"When you work on a personal project in your free time, it gives you energy and ideas. And the thing is, you take that energy and everything you learn in the process back to your full-time job..." ...

Procedurally generating a narrative in Forest of Sleep

November 24, 2015 09:00 AM

Ed Key and Nicolai Troshinsky of Twisted Tree Games are attempting to expand procedural generation into storytelling with their game Forest of Sleep. ...

Game From Scratch

Massive Release of Infocom Text Adventure Design Documents

by at November 24, 2015 01:54 AM

Infocom logo.png

Today over 4000 documents from Infocom were released on as the Infocom cabinet.  This collection of documents contains reams of design information from many classic text adventures including:

  • Planetfall
  • Sorcerer
  • The Hitchhiker’s Guide to the Galaxy
  • A Mind Forever Voyaging
  • Leather Goddesses of Phobos
  • Stationfall
  • Zork Zero


From the blog post announcing the release:

During the production of GET LAMP, I spent a lot of time digitizing or photographing all sorts of artifacts and documents related to Interactive Fiction and text adventures. This included books, advertisements, printouts, and various ephemera that various players or programmers had lying around from that era. This would usually involve one or two ads, maybe a map or two that someone had drawn, and one or two photos snapped at a convention.

But not in the case of Steve Meretzky.

If you’re coming into this relatively new, or even if you need a little brush-up, let me state: Steve Meretzky has earned the title of “Game God” several times over, having been at the center of the early nadir of computer games in the 1980s and persisting, even thriving, in the years since. He continues to work in the industry, still doing game design, 35 years since he started out as a tester at what would become Infocom.

But more than that – besides writing a large amount of game classics in the Interactive Fiction realm, he also was an incredibly good historian and archivist, saving everything.


When we finally connected during production (as it turned out, we lived within 10 miles of each other), Steve showed me his collection of items he had from the days of Infocom (which spanned from roughly 1981 through to the company’s eventual closing and absorption by Activision in the early 1990s). And it was a hell of a collection

It’s of questionable use today, game design has changed a great deal, but the huge volume of information is nothing if not interesting!

Gamasutra Feature Articles

GameStop seeing downturn in Halo, Star Wars -- but is it a digital shift?

November 23, 2015 11:02 PM

The company's most recent quarter showed surprisingly low sales for tentpole titles at the end of this year, but high digital sales may be claiming its numbers. ...

Report: Significant layoffs at Firefall developer Red5

November 23, 2015 10:24 PM

UPDATE Layoffs are confirmed to have hit the studio. The Southern California studio, developers of the MMO shooter Firefall, has reportedly been hit with significant layoffs. ...

This Week in Video Game Blogging: Games without Players

November 23, 2015 08:44 PM

This week, our partnership with game criticism site Critical Distance brings us picks from Riley Macleod on topics ranging from choice developers interviews to envisioning games without players. ...

Nvidia teams up with Stanford researchers for better VR tech

November 23, 2015 08:35 PM

New display tech aims to persistent focus problems from VR, offering clearer and more effective visuals -- and the first products featuring the technology could ship in 2018. ...

In-depth: The decision to un-publish Afro Samurai 2 and refund buyers

November 23, 2015 07:55 PM

Versus Evil has yanked the game down from the PlayStation Network and Steam, and is completely refunding all customers who purchased the game -- general manager Steve Escalante explains. ...

The Indian mobile game market: The next big thing?

November 23, 2015 07:42 PM

SuperData shares a wealth of data about the next big mobile game market -- including the top-performing titles, the cost of user acquisition, and the device split, among other data. ...

Massive, 4,000-page Infocom design and biz archive posted online

November 23, 2015 07:02 PM

The Internet Archive now offers 4,000 pages of archives from the storied 1980s game developer of classics like The Hitchhiker's Guide to the Galaxy. ...

How to make trailers that capture the player's emotional journey

November 23, 2015 06:31 PM

"I record real players playing the games I'm making trailers for. I capture the sounds they make, and I watch how they react to the games. It's just normal folk having honest reactions to the game." ...

Get into the mix of Forza Motorsport 6's audio at GDC 2016

November 23, 2015 06:31 PM

GDC officials highlight a fresh pair of great GDC 2016 race day talks from Turn 10 Studios & Criterion devs about the tricks to making great racing games. ...

Timothy Lottes

CRT Inventory

by Timothy Lottes ( at November 23, 2015 06:16 PM

Makvision M2929 ----------------- 29", _4:3, _800x600__, 30-40_ KHz, 47-90_ Hz, 90___ MHz, slot mask_____, _____0.73 mm pitch, VGA_
HP "1024" D2813 ----------------- 14", _4:3, 1024x768__, 30-49_ KHz, 50-100 Hz, _____ MHz, shadow mask___, ____________ pitch, VGA_
Sony Wega KV-30HS420 ------------ 30", 16:9, _853x1080i, ______ KHz, ______ Hz, _____ MHz, aperture grill, ____________ pitch, HDMI
ViewSonic G75f ------------------ 17", _4:3, 1600x1200_, 30-86_ KHz, 50-180 Hz, 135__ MHz, shadow mask___, 0.21-0.25 mm pitch, VGA_
ViewSonic PS790 ----------------- 19", _4:3, 1600x1200_, 30-95_ KHz, 50-180 Hz, 202.5 MHz, shadow mask___, _____0.25 mm pitch, VGA_
Dell Ultrascan 1600HS D1626HT --- 21", _4:3, 1600x1200_, 30-107 KHz, 48-160 Hz, _____ Mhz, aperture grill, 0.25-0.27 mm pitch, VGA_
Dell Ultrascan 20TX D2026T-HS --- 20", _4:3, 1600x1200_, 31-96_ KHz, 50-100 Hz, _____ MHz, aperture grill, _____0.26 mm pitch, VGA_

Gamasutra Feature Articles

Baked soft shadows in Unity 5

November 23, 2015 06:00 PM

"To make your scenes look more believable it's worth considering what soft shadows can do for you... I will demonstrate some comparison cases to better understand how baked soft shadows work and can be set up." ...

Game From Scratch

Android Studio 2.0 Preview Available

by at November 23, 2015 05:54 PM


At the Android Developer Summit, Google just announced Android Studio 2.0 is available for download in preview form.  The two major new features will both be relevant for game developers, Instant Run which enables hot swapping of code on device and a GPU profiler, for profiling OpenGL ES code performance.


From the Android Developers blog:

Android Studio 2.0 Preview

Posted by, Jamal Eason, Product Manager, Android

One the most requested features we receive is to make app builds and deployment faster in Android Studio. Today at theAndroid Developer Summit, we’re announcing a preview of Android Studio 2.0 featuring Instant Run that will dramatically improve your development workflow. With Android Studio 2.0, we are also including a preview of a new GPU Profiler.

All these updates are available now in the canary release channel, so we can get your feedback. Since this initial release is a preview, you may want to download and run an additional copy of Android Studio in parallel with your current version.

New Features in Android Studio 2.0
Instant Run: Faster Build & Deploy

Android Studio’s instant run feature allows you to to quickly see your changes running on your device or emulator.

Getting started is easy. If you create a new project with Android Studio 2.0 then your projects are already setup. If you have a pre-existing app open Settings/Preferences, the go to Build, Execution, Deployment → Instant Run. Click on Enable Instant Run... This will ensure you have the correct gradle plugin for your project to work with Instant Run.

Enable Instant Run for Android Studio projects

Select Run as normal and Android Studio will perform normal compilation, packaging and install steps and run your app on your device or emulator. After you make edits to your source code or resources, pressing Run again will deploy your changes directly into the running app.

New Run & Stop Actions in Android Studio for Instant Run

For a more detailed guide setup and try Instant Run, click here.

GPU Profiler

Profiling your OpenGL ES Android code is now even easier with the GPU Profiler in Android Studio. The tool is in early preview, but is very powerful and not only shows details about the GL State and Commands, you can record entire sessions and walk through the GL Framebuffer and Textures as your app is running OpenGL ES Code.

Android Studio GPU Profiler

To get started, first download the GPU Debugging Tools package from the Android Studio SDK Manager. Click here for more details about the GPU Profiler tool and how to set up your Android app project for profiling.

Whats Next

This is just a taste of some of the bigger updates in this latest release of Android Studio. We'll be going through the full release in more detail at the Android Developer Summit (livestreamed on Monday and Tuesday). Over the next few weeks, we'll be showing how to take advantage of even more features in Android Studio 2.0, so be sure to check back in.

If you're interested in more Android deep technical content, we will be streaming over 16 hours of content from the inaugural Android Developer Summit over the next two days, and together with Codelabs, all of this content will be available online after the Summit concludes.

Android Studio 2.0 is available today on the Android Studio canary channel. Let us know what you think of these new features by connecting with the Android Studio development team on Google+.


I wonder how much of this functionality will be made available upstream to the IntelliJ IDE? 

Gamasutra Feature Articles

Forget all the comparisons to cinema--games are more like operas

November 23, 2015 05:32 PM

'Every time I see an opera I cannot help but think of video games, for they too necessarily combine many art forms' ...

Game From Scratch

Cocos2D-X Tutorial Series: Playing Sound Effects and Music

by at November 23, 2015 05:31 PM



In this tutorial we are going to look at audio programming in Cocos2d-x.  We will look at playing music and sound effects using SimpleAudioEngine, one of two engines built into Cocos2d-x.  There is a second, newer, more commplex and experimental audio engine AudioEngine, that we will discuss later.  Let’s start straight away by playing some music.  To make use of SimpleAudioEngine we need to add an additional include call:

#include "SimpleAudioEngine.h"


Next we need a song of some sorts to play, simply copy an appropriate file into your resources folder.  Myself I used an mp3 file named creatively enough song.mp3.

Supported Audio File Formats

The audio formats supported by Cocos2D-x depend entirely on what platform you run on.  The primary thing to be aware of is the ogg format is the preferred music format on Android platforms, while it is completely unsupported on iOS, which prefers MP3.

You should be aware that the MP3 format is patent encumbered format and generally should be avoided when possible.  If your app reaches certain sales thresholds, you may be required to pay license fees.  Sadly this generally isn’t an option on iOS devices as MP3 is the primary audio format used.  For sound effects, WAV are commonly used offering quick playback ability at the cost of file size.  Here are the details of supported audio files on iOS

Time now for some coding.  Implement the following init() method:

bool HelloWorld::init()
   if (!Layer::init())
      return false;

   auto audio = CocosDenshion::SimpleAudioEngine::getInstance();

   return true;

That is all that is required to load and play a music file. In fact the preloadBackgroundMusic() call wasn't even required so we could have used even less code. However preloading your music guarantees that you will not suffer a slow down the first time a song plays. You can also pause and resume playback of background music, or switch tracks completely, like so:

   eventListener->onKeyPressed = [audio](EventKeyboard::KeyCode keyCode, Event* event) {

      switch (keyCode) {
         case EventKeyboard::KeyCode::KEY_SPACE:
            if (audio->isBackgroundMusicPlaying())

         case EventKeyboard::KeyCode::KEY_RIGHT_ARROW:

         case EventKeyboard::KeyCode::KEY_LEFT_ARROW:

   _eventDispatcher->addEventListenerWithFixedPriority(eventListener, 2);

Hitting the spacebar will toggle the playback of the currently playing song.  Hitting the right arrow will start playing (or start over if already playing) song2.mp3. Hitting the left arrow will start or re-start playback of song.mp3.  You will notice from this example that only one song can be played at a time.  Generally this isn’t a limitation as it is normal to only have one active sound track at a time. 

setBackgroundMusicVolume() doesn't work!

A bit of a warning, at least on Windows, calling setBackgroundMusicVolume() does nothing, making it impossible to change the volume of a playing music file. This may not be the case on other platforms, I did not test. It was filed as a bug a long time back and does not appear to have been addressed.


Now let's look at playing sound effects instead.  Playing music and effects is almost identical.  The biggest difference is that sound effects are expected to support multiple concurrent instances.  That is to say, while you can only play one song at a time, you can play multiple sound effects at once. Consider this sample:

bool HelloWorld::init()
   if (!Layer::init())
      return false;

   auto audio = CocosDenshion::SimpleAudioEngine::getInstance();


   Director::getInstance()->getScheduler()->schedule([audio](float delta) {
   }, this, 1.5f, 0, 0.0f, false, "myCallbackKey");

   return true;


In this example we preload two WAV sound effects, a gun cocking and a gun shot.  Playing a sound effect is as simple as calling playEffect() passing in the file name.  Of course, be certain to copy the appropriate sound files to your project’s resource folder before running this example.  Next this example queues up a lambda method to be called 1.5 seconds of the gun cocking sound is played to play our gun shot sound.  At this point we are done with our gun cocking effect so we unload it from memory using unloadEffect().  You can still call playEffect with that file in the future, but it will result in the file being loaded again.


This example might be somewhat convoluted, but it illustrates and works around a key weakness in the CocosDenshion audio library.  It is a very simple and straight forward library but if you want to do “advanced” things like detecting when a song or audio effect has ended, unfortunately this functionality is not available.  You either have to use the experimental AudioEngine, which we will cover later, or use an external audio library such as FMOD.  SimpleAudioEngine is extremely easy to use, but not very powerful, so it’s certainly a trade off.  If you just need background music and fire and forget sound effects SimpleAudioEngine should be just fine for you.


One final topic to cover is handling when your app is minimized or forced into the background, you most certainly want to stop audio playback.  This is thankfully easily accomplished in your AppDelegate there are a pair of methods, applicationDidEnterBackground() and applicationWillEnterForeground().  Simply add the following code:

void AppDelegate::applicationDidEnterBackground() {
   auto audio = CocosDenshion::SimpleAudioEngine::getInstance();

void AppDelegate::applicationWillEnterForeground() {
   auto audio = CocosDenshion::SimpleAudioEngine::getInstance();


This will cause all of your currently playing sound effects and music files to be paused when your application enters the background and they will all result when your application regains focus.

Gamasutra Feature Articles

Classic Postmortem: Star Wars Starfighter

November 23, 2015 04:48 PM

LucasArts' action-heavy space sim was released fourteen years ago. Here's an in-depth postmortem by the developers of the game that first appeared in Game Developer magazine. ...

New data highlights gender split for mobile game genres

November 23, 2015 04:28 PM

New data picked up by TouchArcade shows that men and women have very different video game habits on mobile. ...

An easy trick for making loot drops more engaging

November 23, 2015 03:53 PM

"Random was too random. It was time to introduce some logic to the loot table. Of course, if every drop is Health exactly when you need it, the game becomes predictable. That's not fun either." ...

Desert Bus for Hope raises over $600,000 for Child's Play

November 23, 2015 03:42 PM

Charity gaming marathon Desert Bus for Hope finished over the weekend, and this year the fundraiser brought in $676.883 in donations, taking the lifetime total of money raised since 2007 to $3.11 million. ...

Payday 2 dev apologizes for microtransaction U-turn

November 23, 2015 02:38 PM

After getting on the wrong side of fans by adding microtransactions to Payday 2, despite multiple staffers claiming that would never happen, developer Overkill has issued an apology via its Steam page. ...

Writing a game engine from scratch: Data and cache

November 23, 2015 12:09 PM

"In order to work with data, we chose a Top-down approach, going from overall Engine Architecture right down into Memory Management. But we still haven't talked about the actual data we will manage. We will do this here." ...

How to cross-sell items in your game

November 23, 2015 09:02 AM

"It could be interesting to learn if certain items are consistently purchased together. This data can be used for cross-selling and up selling, for promotions and for identifying customer segments." ...

7 great minigames that game developers should study

November 23, 2015 09:02 AM

An engaging minigame can deepen a players engagement in the overarching game. We look at 7 instructive examples that game developers should examine closely. ...

Game From Scratch

The First LibGDX Jam is a Go. Topic Voting Begins Now

by at November 22, 2015 03:34 PM


As per this blog post the first ever LibGDX game jam is happening in mid December and topic voting has begun.  From the announcement:


The 10 Rules of Jamming

  1. You must use libGDX to create a game that fits the theme
  2. You may work alone or in a team. Only one submission per person/team is allowed
  3. You may use pre-existing code, e.g. libraries like Ashley, or your own code libraries
  4. You may use pre-existing art, e.g. assets from OpenGameArt, or your own art
  5. You may use external tools like Tiled or Overlap2D
  6. You must not re-skin an already existing game or prototype!
  7. You must submit your game before the end of the 18th of January via the jam’s site on (to be made public :))
  8. You must publish the source of your game, e.g. to GitHub
  9. You must submit your game to the libGDX Jam page before the end of day January 18th, UTC-12!
  10. If you want to win one of the sponsored prizes, you must tweet about your game and document its development, using the hashtag “#libGDXJam” and the handles “@robovm” and “@robotality

Prizes & Judging

We are happy to have RoboVM and Robotality as sponsors for the following prizes:

  1. Grand Prize: Mac Mini, sponsored by RoboVM
  2. Silver: iPad, sponsored by RoboVM
  3. Bronze: iPod Touch, sponsored by RoboVM
  4. For 20 random submissions: Steam keys for Halfway, sponsored by Robotality
  5. For another 5 random submissions: libGDX Jam t-shirt, by yours truely

To qualify for any of the prizes, you’ll need to follow rule 10 as outlined above. Judging works as follows:

  • The community can vote on from the 19th of January to the 2nd of February
  • The Grand Prize will be awarded to the entry with the highest community votes on This way the highest quality entry will win!
  • The Silver and Bronze prizes will be awarded to the entries with the best mixture of dev logs and tweets and community votes. Our sponsors and the libGDX core team will pick these entries. This should motivate people to make some noise on the web and document their progress for the greater good of the community!
  • The random awards guarantee that everyone has a chance to win a prize!
  • The winners will be announced on the 3rd of February!

To view suggested comments and to cast your vote, head on over here.

Timothy Lottes

Cross-Invocation Data Sharing Portability

by Timothy Lottes ( at November 22, 2015 12:35 PM

A general look at the possibility of portability for dGPUs with regards to cross-invocation data sharing (aka to go next after ARB_shader_ballot which starts exposing useful SIMD-level programming constructs). As always I'd like any feedback anyone has on this topic, feel free to write comments or contact me directly. Warning this was typed up fast to collect ideas, might be some errors in here...

References: NV_shader_thread_group | NV_shader_thread_shuffle | AMD GCN3 ISA Docs

NV Quad Swizzle (supported on Fermi and beyond)
shuffledData = quadSwizzle{mode}NV({type} data, [{type} operand])
(1.) "mode" is {0,1,2,3,X,Y}
(2.) "type" must be a floating point type (implies possible NaN issues issues with integers)
(3.) "operand" is an optional extra unshuffled operand which can be added to the result
The "mode" is either a direct index into the 2x2 fragment quad, or a swap in the X or Y directions.

swizzledData = quadSwizzleAMD({type} data, mode)
(1.) "mode" is a bit array, can be any permutation (not limited to just what NVIDIA exposes)
(2.) "type" can be integer or floating point

Possible Portable Swizzle Interface
bool allQuad(bool value) // returns true if all invocations in quad are true
bool anyQuad(bool value) // returns true for entire quad if any invocations are true
swizzledData = quadSwizzleFloat{mode}({type} data)
swizzledData = quadSwizzle{mode}({type} data)
(1.) "mode" is the portable subset {0,1,2,3,X,Y} (same as NV)
(2.) "type" is limited to float based types only for quadSwizzleFloat()
This is the direct union of common functionality from both dGPU vendors. NV's swizzled data returns 0 for "swizzledData" if any invocation in the quad is inactive according to the GL extension. AMD returns 0 for "swizzledData" only for inactive invocations. So the portable spec would have undefined results for "swizzledData" if any invocation in the fragment quad is inactive. This is a perfectly acceptable compromise IMO. Would work on all AMD GCN GPUs and any NVIDIA GPU since Fermi for quadSwizzlefloat(), and since Maxwell for quadSwizzle() (using shuffle, see below), this implies two extensions. Quads in non fragment shaders are defined by directly splitting the SIMD vector into aligned groups of 4 invocations.

NV Shuffle (supported starting with Maxwell)
shuffledData = shuffle{mode}NV({type} data, uint index, uint width, [out bool valid])
(1.) "mode" is one of {up, down, xor, indexed}
(2.) "data" is what to shuffle
(3.) "index" is a invocation index in the SIMD vector (0 to 31 on NV GPUs)
(4.) "width" is {2,4,8,16, or 32}, divides the SIMD vector into equal sized segments
(5.) "valid" is optional return which is false if the shuffle was out-of-segment
Below the "startOfSegmentIndex" is the invocation index of where the segment starts in the SIMD vector. The "selfIndex" is the invocation's own index in the SIMD vector. Each invocation computes a "shuffleIndex" of another invocation to read "data" from, then returns the read "data". Out-of-segment means that "shuffleIndex" is out of the local segment defined by "width". Out-of-segment shuffles result in "valid = false" and sets "shuffleIndex = selfIndex" (to return un-shuffled "data"). The computation of "shuffleIndex" before the out-of-segment check depends on "mode".
(indexed) shuffleIndex = startOfSegmentIndex + index
(_____up) shuffleIndex = selfIndex - index
(___down) shuffleIndex = selfIndex + index
(____xor) shuffleIndex = selfIndex ^ index

Also can do swizzle across segments of 32 invocations using the following math.
and_mask = offset[4:0];
or_mask = offset[9:5];
xor_mask = offset[14:10];
for (i = 0; i 32; i++) {
j = ((i & and_mask) | or_mask) ^ xor_mask;
thread_out[i] = thread_valid[j] ? thread_in[j] : 0; }

The "_mask" values are compile time immediate values encoded into the instruction.

AMD VOP_DPP (starts with GCN3: Tonga, Fiji, etc)
DPP can do many things,
For a segment size of 4, can do full permutation by immediate operand.
For a segment size of 16, can shift invocations left by an immediate operand count.
For a segment size of 16, can shift invocations right by an immediate operand count.
For a segment size of 16, can rotation invocations right by and immediate operand count.
For a segment size of 64, can shift or rotate, left or right, by 1 invocation.
For a segment size of 16, can reverse the order of invocations.
For a segment size of 8, can reverse the order of invocations.
For a segment size of 16, can broadcast the 15th segment invocation to fill the next segment.
Can broadcast invocation 31 to all invocations after 31.
Has option of either using "selfIndex" on out-of-segment, or forcing return of zero.
Has option to force on invocations for the operation.

AMD DS_PERMUTE_B32 / DS_BPERMUTE_B32 (starts with GCN3: Tonga, Fiji, etc)
Supports something like this (where "temp" is in hardware),
bpermute(data, uint index) { temp[selfIndex] = data; return temp[index]; }
permute(data, uint index) { temp[index] = data; return temp[selfIndex]; }

Possible Portable Shuffle Interface : AMD GCN + NV Maxwell
This is just a start of ideas, have not had time to fully explore the options, feedback welcomed...
SIMD width would be different for each platform so developer would need to build shader permutations for different platform SIMD width in some cases.

butterflyData = butterfly{width}({type} data)
Where "width" is {2,4,8,16,32}. This is "xor" mode for shuffle on NV, and DS_SWIZZLE_B32 on AMD (with and_mask = ~0, and or_mask = 0) with possible DPP optimizations on GCN3 for "width"={2 or 4}. The XOR "mask" field for both NV and AMD is "width>>1". This can be used to implement a bitonic sort (see slide 19 here).

TODO: Weather is nice outside, will write up later...

reducedData = reduce{op}{width}({type} data)
(1.) "op" specifies the operation to use in the reduction (add, min, max, and, ... etc)
(2.) "width" specifies the segment width
At the end of this operation only the largest indexed invocation in each segment has the result, the values for all other invocations in the segment are undefined. This enables both NV and AMD to have optimal paths. This uses "up" or "xor" mode on NV for log2("width") operations. Implementation on AMD GCN uses DS_SWIZZLE_B32 as follows,
32 to 16 => DS_SWIZZLE_B32 and_mask=31, or_mask=0, xor_mask=16
16 to 8 => DS_SWIZZLE_B32 and_mask=31, or_mask=0, xor_mask=8
8 to 4 => DS_SWIZZLE_B32 and_mask=31, or_mask=0, xor_mask=4
4 to 2 => DS_SWIZZLE_B32 and_mask=31, or_mask=0, xor_mask=2
2 to 1 => DS_SWIZZLE_B32 and_mask=31, or_mask=0, xor_mask=1
64 from finalized 32 => V_READFIRSTLANE_B32 to grab invocation 0 to apply to all invocations

Implementation on AMD GCN3 uses DPP as follows,
16 to 8 => reverse order of 16-wide (DPP_ROW_MIRROR)
8 to 4 => reverse order of 8-wide (DPP_ROW_HALF_MIRROR)
4 to 2 => reverse order using full 4-wide permutation mode
2 to 1 => reverse order using full 4-wide permutation mode
32 from finalized 16 => DPP_ROW_BCAST15
64 from finalized 32 => DPP_ROW_BCAST32

reducedData = allReduce{op}{width}({type} data)
The difference being that all invocations end up with the result. Uses "xor" mode on NV for log2("width") operations. On AMD this is the same as "reduce" except for "width"={32 or 64}. The 64 case can use V_READLANE_B32 from the "reduce" version to keep the result in an SGPR to save from using a VGPR. The 32 case can use DS_SWIZZLE_B32 for the 32 to 16 step.

Possible Portable Shuffle Interface 2nd Extension : AMD GCN3 + NV Maxwell
This is just a start of ideas, have not had time to fully explore the options, feedback welcomed...
SIMD width would be different for each platform so developer would need to build shader permutations for different platform SIMD width in various cases.

Backwards permutation of full SIMD width is portable across platforms, maps on NV to shuffleNV(data, index, 32), and DS_BPERMUTE_B32 on AMD,
permutedData = bpermute(data, index)

Geeks3D Forums

NVIDIA GeForce driver 358.16 for Linux, FreeBSD and Solaris

November 22, 2015 01:40 AM

Download via NVIDIA UNIX driver portal

Fixed a regression, introduced in 358.09, that caused incorrect rendering of OpenGL stereo applications in combination with Quadro Sync on certain GPUs.Fi...

Game From Scratch

NCSoft Add JavaScript Support to Unreal Engine

by at November 21, 2015 11:31 PM


Until now your language choices when using Unreal Engine have either been the high level graphical Blueprints or low level C++.  Today however NCSoft, makers of Lineage, Guildwars and more just release an extension that adds Javascript support to UE4.  Announced on the UE4 forums (login may be required) the extension was released on Github with full source under the Apache2 open source license.  From the readme:

  • Powered by latest V8 (ES6)
  • CommonJS modules
  • Full access to the whole UnrealEngine API
  • Free to subclass existing classes including blueprint
  • Web-dev like UMG (Jade, pseudo-css, pseudo-angular.js)
  • Live reload
  • Communicate with outer world: REST, process(pipe), arraybuffer, ...
  • Bridge API for editor extension
  • Auto-completion for Visual Studio (auto-generated *.d.ts)
  • Dedicated Javascript console on UnrealEditor

The add-on is tightly integrated with Unreal including the ability to subclass existing classes:

class MyActor extends Actor {
  properties() {
  RPC(x/*int*/) /*Server+Reliable*/ {
    console.log('This function is replicated',this.MyProp++);
let MyActor_C = require('uclass')()(global,MyActor);
if (GWorld.IsServer()) { 
  new MyActor_C(GWorld);

Very cool.  Head on over to the Github page for installation instructions.

Geeks3D Forums

Intel HD Graphics Driver

November 21, 2015 07:12 PM

Driver Version: &

This driver supports Star Wars Battlefront*, Defense of ...

Timothy Lottes

ISA Toolbox

by Timothy Lottes ( at November 21, 2015 09:17 AM

For years now I have found that nearly everything I work on can be made better by leveraging ISA features which are not always exposed in all the graphics APIs. For example, currently working on a project now which could use the combination of the following,

(1.) From AMD_shader_trinary_minmax, max3(). Direct access to max of three values in a single V_MAX3_F32 operation. If the GPU has 3 read ports on the register file for FMA, might at well take advantage of that for min/max/median. AMD's DX driver shader compiler automatically optimizes these cases, for example "min(x,min(y,z))" gets transformed to "min3(x,y,z)".

(2.) Direct exposure of V_SIN_F32 and V_COS_F32, which have a range of +/- 512 PI and take normalized input. Avoids and extra V_MUL_F32 and V_FRACT_F32 per operation. Nearly all the time I use sin() or cos() I'm in range (no need for V_FRACT_F32). Nearly all the time I'm in the {0 to 1} range for 360 degrees, and need to scale by 2 PI only so code generation can later scale back by 1/2 PI. Portable fallback for machines without V_SIN_F32 and V_COS_F32 like functionality looks like,

float sinNormalized(float x) { return sin(x * 2.0 * PI); }
float cosNormalized(float x) { return cos(x * 2.0 * PI); }

(3.) Branching if any or all of the SIMD vector want to do something. Massively important tool to avoid divergence. For example in a full screen triangle, if any pixel needs the more complex path, just have the full SIMD vector only do the complex path instead of divergently processing both complex and simple. API can be quite simple,

bool anyInvocations(bool x)
bool allInvocations(bool x)

Example of how these could map in GCN (these scalar instructions execute in parallel with vector instructions, so low cost),

// S_CMP_NEQ_U64 x,0
if(anyInvocations(x)) { }

// S_CMP_EQ_U64 x,-1
if(allInvocations(x)) { }

(4.) Quad swizzle for fragment shaders for cross-invocation communication is super useful. Given a 2x2 fragment quad as follows,


These functions would be quite useful (they map to DS_SWIZZLE_B32 in GCN),

// Swap value horizontally.
type quadSwizzle1032(type x)

// Swap value vertically.
type quadSwizzle2301(type x)

For example one could simultaneously write out the results of a fragment shader to the standard full screen pass and write out the 1/2 x 1/2 resolution next smaller mip level at the same time using an extra image store. Just use the following to do a 2x2 box filter in the shader,

boxFilterColor = quadSwizzle1032(color) + color;
boxFilterColor += quadSwizzle2301(boxFilterColor);