Planet Gamedev

Geeks3D Forums

(WebGL) AlteredQualia woolly mammoth skeleton

April 18, 2014 03:46 PM

AlteredQualia woolly mammoth skeleton works now on Nexus 4 with GPU driver update.

[img]https://farm3.staticflickr.com/292...

Qualcomm Adreno GPU driver 17.04.2014

April 18, 2014 03:42 PM

Quote
User-mode driver binaries for Qualcomm’s Adreno 3xx GPU on Nexus 4, 5 & 7 devices running Google Android 4.4.2 KitKat[/ur...

Real-Time Rendering

Free/Cheap Processing Course by Andrew Glassner

by Eric at April 18, 2014 02:40 PM

Andrew Glassner has made an 8 week course about the graphics language Processing. The first half of the course is free; if you find you like it, the second half is just $25. Even if you don’t want to take the course, you should watch the 2.5 minute video at the site – beware, it may change your mind. The video gives a sense of the power of Processing and some of the wonderful things you can do with it. My small bit of experience with the language showed me it’s a nice way to quickly display and fiddle around with all sorts of graphical ideas. While I dabbled for a week, Andrew used it for half a decade and has made some fascinating programs. Any language that can have such a terrible name and still thrive in so many ways definitely has something going for it.

glassner1



Procedural World

Video Update for April 2014

by Miguel Cepero (noreply@blogger.com) at April 18, 2014 12:58 PM

Wondering what happened in the last few months? Here is an update:


There are several things we did that were not covered in this update. You will notice a river in the background but there is no mention about water.


It is not that we are hydrophobic or that we want to tease you about this feature, we just want to spend more time improving the rendering.

I also go on in this update about how clean and sharp our new tools are. There is indeed a big difference in the new toolset, but still there are serious issues with aliasing when you bring detail beyond what the voxels can encode. For instance, the line tool now can do much better lines, but we still cannot do a one-voxel thick line that goes in any angle. This is because in order to fix the aliasing in this line would need sub-voxel resolution. So it OK to expect cleaner lines, but they can still break due to aliasing.

iPhone Development Tutorials and Programming Tips

Open Source iOS Component That Makes It Easier To Get Permission To Use Photos And Contacts

by Johann at April 18, 2014 06:13 AM

Post Category    Featured iPhone Development Resources,iOS UI Controls,iPad,iPhone,Objective-C

One major issue that arises with iOS apps that use photos or contacts is that the user needs to give permission, and if the user declines to give access they will later need to go into settings and adjust the permissions.

Here’s a library from Cluster called ClusterPrePermissions that aims to help solve this issue by displaying a prompt asking the user if they want to give permission before actually giving permission.

ClusterPrePermission will check the authorization status of photos and contacts, and if that status not yet determined will display a customizable prompt where you can ask the user for “pre-permission”.

And the readme states that this approach has been extremely successful for Cluster: “For photos alone, 46% of people who denied access in a pre-permissions dialog ended up granting access when asked at a better time later.”

Here is a set of images from the readme showing ClusterPrePermissions in action:

ClusterPrePermissions

You can find ClusterPrePermissions on Github here.

You can read more about this pre-permission approach in this article by Cluster’s Brenden Mulligan.

A nice approach to solving a common issue.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Open Source iOS Component That Makes It Easier To Get Permission To Use Photos And Contacts

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Gamasutra Feature Articles

Understanding the successful relaunch of Final Fantasy XIV

April 18, 2014 04:00 AM

Producer and director Naoki Yoshida tells Gamasutra why he rebooted Final Fantasy XIV. ...



Game From Scratch

Substance Painter release Beta 3 to Steam

by Mike@gamefromscratch.com at April 18, 2014 12:14 AM

 

I suck at texturing.

 

There, I said it.  I love 3D modeling, I even enjoy rigging and animating.  While not my favorite activity, I am even OK with UV unwrapping…

 

But texturing, I suck at texture mapping.

 

Over the years I have tried a number of solutions that make texturing easier going back to the early days of 3D Studio Max plugins that allow you to paint directly on your models.  Since then, those tools have become progressively more built in to the base package but at the end of the day, the vast majority of texturing still takes place in Photoshop and I still suck at it.

 

Enter Substance Painter.  It appeared on Steam about a month back and I’ve been playing around with it ever since.  I intend to cover it in more detail soon, in fact I would have already if it weren't for the massive influx of goodies that came with GDC this year.  Anyways, stay tuned for more details shortly…image

 

For now, a spot a of news.  Beta 3 was just released.  Oh, and if you buy during the beta it’s 50% off.

 

Enough talking, so what exactly is Substance Painter?

 

Short version; it’s the program that makes me not completely suck at texturing.  That’s about the biggest endorsement I can give.

 

Long version, well, I’ll use their wording for that:

 

Substance Painter is a brand new 3D Painting app featuring never before seen features and workflow improvements to make the creation of textures for modern games easier than ever.


At Allegorithmic, we have a long history of working very closely with our customers, from the small independents to the largest AAA studios. Today we want you to help us design the ultimate painting tool and bring innovation and state of the art technology to every artist out there at a fair price.

 

Today, as the title suggests, they released Beta 3.  As to what’s new in BETA 3:

Testing focus

  • 2D View
Change list
  • Added: Seamless 2D View!
  • Added: Bitmap layer masks
  • Added: Environment exposure control
  • Updated: Fill Layers now use the Tools windows to set their properties
  • Updated: Materials can be applied to Fill Layers
  • Updated: Added more stencils in the stencil library
  • Updated: Particles presets updated for faster computation
  • Updated: PBR shader optimization and quality improvement for lower quality settings
  • Fixed: Layers thumbnails are linked to the currently selected channel
  • Fixed: Lots of crashes

 

Sound interesting?  Here is a video of Substance Painter in action:

There is also a free trial available.  It’s a stand alone program, although some of the import options are disabled right now ( I used OBJ personally, from Blender ).  Keep in mind it is a beta, and feels Beta-like at times.  Some features are currently missing and performance can occasionally suffer.  On the other hand, outside of some missing features, it feels production ready.  I hope to have a more detailed preview available soon.

 

If you try it out, let me know what you think.

iPhone Development Tutorials and Programming Tips

Open Source Library For Creating Great Looking Animated And Interactive Line Graphs

by Johann at April 17, 2014 10:57 PM

Post Category    Featured iPhone Development Resources,iOS Development Libraries,Objective-C,Open Source iOS Libraries And Tools

I’ve mentioned a number of graphing and charting libraries such as the excellent MagicPie for creating animated pie charts.

Here’s a library submitted by Boris Emorine for producing great looking line graphs that has number of nice unique features.

These features include:

- Adjustable animations on display of the graph
- Line smoothing using bezier curves for smoothed line graphs
- Touch reporting and indication on the graph showing the closest point to the users touch
- Custom alpha values so graphs can be made semi-transparent if desired
- Easy snapshotting of the graphs

Here’s an image from the readme showing BEMSimpleLineGraph in action:
BEMSimpleLineGraph

You can find BEMSimpleLineGraph on Github here.

A very nice library for creating line graphs.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Open Source Library For Creating Great Looking Animated And Interactive Line Graphs

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Game Design Aspect of the Month

Game Design: Creating a System Formula (Part IV)

by noreply@blogger.com (Sande Chen) at April 17, 2014 03:40 PM

In Part I, game designer Bud Leiser explains how to use the Fibonacci series in system design. In Part II, he shows the grind gap and how the amount of grind can quickly accelerate when using the Fibonacci series. In Part III, he discusses how to evaluate the curve based on design goals. In Part IV, he suggests how to progress from the general guideline to cover all other elements in the game.

Actually…I could see implementing this curve into a real RPG if: for the player to survive we would probably have to give lots of item drops and a low cost way of healing outside of combat. (Final Fantasy health potions anyone?).  We can also try to figure out what strategy the player will use to overcome this curve: What might happen is players grind longer at a given level to buy his armor and boots.
They might even skip weapon levels, instead of buying each one progressively they might save up money to buy 2 levels ahead, and then use that powerful sword in combat, if he has enough health to survive 1 combat he could use cheap healing outside of combat. In other words relying on that high level sword to get him through 1 combat and not worrying about keep up with armor until absolutely necessary. If we wanted to encourage this type of play we could set the monster damage levels at rates unlikely to kill a player in a single combat. Drop potions frequently and even give the player armor pieces as common rewards. Assuming he has free time out of combat to heal up to full without being attacked, this would be a completely valid RPG style.

-Or-

You could create these cost progressions using “suits” (Armor, gauntlet, belt, boots, helmet, weapon). Then assign % of that to each piece. For example:

SuitsTotal CostWeaponsSword CostArmorArmor CostHelmetHelmet Cost
A5020%1025%1310%5
B10020%2025%2510%10
C15020%3025%3810%15
D25020%5025%6310%25
E40020%8025%10010%40
F65020%13025%16310%65
G105020%21025%26310%105
H170020%34025%42510%170
I275020%55025%68810%275
J445020%89025%111310%445
K720020%144025%180010%720
L1165020%233025%291310%1165
M1885020%377025%471310%1885
N3050020%610025%762510%3050
O4935020%987025%1233810%4935
P7985020%1597025%1996310%7985

With this we have a general idea of how much the player is making and how much things should cost.

The most important thing is we didn’t have to spend hours making these prices individually. 

We have at the very least a general guideline. And we once we have a guideline that works, that we understand, and that curves the way we want to (meaning the player progresses at a rate that we want them to, and slow down where we want them to). We can now add elements wherever we want. And feel free to Fudge the numbers, give the player a cool Fire Sword and increase the value 10%, or 5% or 500gp.

[This article originally appeared on Bud Leiser's personal blog.]

Bud Leiser beat Nintendo’s original Zelda when he was just 3 years old. Then went on to win money and prizes playing: D&D Miniatures, Dreamblade, Magic the Gathering and The Spoils. He’s just returned from Vietnam where he helped manage Wulven Studios as their Lead Game Designer. He was responsible for creating internal projects, game design documents and communicating with clients to help them succeed in the post-freemium app market.   



iPhone Development Tutorials and Programming Tips

Extensive Functional Programming Inspired Categories For NSArray, NSSet, And NSDictionary

by Johann at April 17, 2014 02:22 PM

Post Category    Featured iPhone Development Resources,iOS Development Libraries,Objective-C,Open Source iOS Libraries And Tools

Early this year I mentioned the release of an Xcode 5 compatible version of the excellent CodePilot was released by Macoscope.

Here is an extensive functional programming inspired library released from Macoscope providing categories for NSArray, NSSet, and NSDictionary providing a clean syntax for many common operations making extensive use of blocks.

These utilities include functionality for searching, sorting, counting, joining, and more.

Here’s an example from the readme showing how one would check an NSArray to see how many elements contain the letter “a”:

NSArray *elements = @[@"Warsaw", @"Berlin", @"London", @"New York", @"Paris"];

NSInteger count = [elements mcs_count:BOOL^(NSString *object) {
    return [object rangeOfString:@"a"].location != NSNotFound;
}];

//result 2

You can read more about MCSCollectionUtility in an article by Rafal Augustyniak over on the Macoscope blog.

You can find MCSCollectionUtility on Github here.

An excellent collection of enhancements for NSArray, NSSet, NSDictionary.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Extensive Functional Programming Inspired Categories For NSArray, NSSet, And NSDictionary

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Geeks3D Forums

AMD Core Math Library (ACML) beta 6.0 available

April 17, 2014 12:39 PM

Quote
ACML Beta 6.0 Release Leverages the Power of Heterogeneous Compute

AMD is releasing a Beta of the next release of the AMD Core Math Library (ACML).  ACML provi...

AMD GPUPerfAPI 2.13 released

April 17, 2014 11:57 AM

GPUPerfAPI is AMD’s library for accessing GPU performance counters on ATI Radeon graphics cards. It is used by GPU PerfStudio 2 and AMD CodeXL and is also available to ...

Timothy Lottes

A Survey of Efficient Representations for Independent Unit Vectors

by Timothy Lottes (noreply@blogger.com) at April 17, 2014 11:26 AM

A Survey of Efficient Representations for Independent Unit Vectors

iPhone Development Tutorials and Programming Tips

Open Source iOS Library Providing A Number Of Nice View Transitions

by Johann at April 17, 2014 06:19 AM

Post Category    Featured iPhone Development Resources,iOS Development Libraries,Objective-C,Open Source iOS Libraries And Tools

I’ve mentioned a number of resources related to the iOS 7 transitioning api such as these tutorials on creating transitions, and making your transitions interactive, and this library of transitions.

Here’s an open source library from shu223 providing even more view transitions using iOS 7′s UIViewControllerAnimatedTransitioning protocol called Animated Transitions Gallery.

There are over 40 transitions included within the library including zoom/fade style transitions, line removal transitions, falling brick transitions, and 3D transitions.

This animation from the readme shows several of the transitions in action:

animatedtransitiongallery

You can find AnimatedTransitionGallery on Github here.

A nice collection of transitions.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Open Source iOS Library Providing A Number Of Nice View Transitions

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Tutorial: Step-By-Step Guide To Creating A Path Drawing Game With Sprite Kit

by Johann at April 17, 2014 01:08 AM

Post Category    Featured iPhone Development Resources,Game Programming,iOS Development Tutorials,Objective-C

Some of the top grossing games on the iPhone and iPad have been line/path drawing games with Flight Control and Harbor Master being among the most famous.

Here’s a tutorial by Jean-Pierre Distler that goes through process of creating a basic line drawing game using Sprite Kit.

The tutorial covers setting up the game background, the basic algorithm for drawing lines, getting the character to follow the drawn path and angle correctly, detect collisions and more.

Here’s an image from the tutorial showing the character following a drawn path:

Rotated Pig

You can find the tutorial over on the Ray Wenderlich blog.

A nice guide to creating a line drawing game.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Tutorial: Step-By-Step Guide To Creating A Path Drawing Game With Sprite Kit

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Geeks3D Forums

AMD Mantle whitepaper

April 16, 2014 08:25 PM

No summary, the PDF didn't let me grab text...
Download whitepaper here

Register for Mantle SDK here

Game From Scratch

LibGDX Tutorial 11: Tiled Maps Part 1: Simple Orthogonal Maps

by Mike@gamefromscratch.com at April 16, 2014 07:37 PM

 

If you’ve never used Tiled read this first!

 

In this tutorial part we are going to look at loading orthogonal maps in LibGDX.  Orthogonal basically means “at a right angle to” which is a fancy way of saying the camera is looking straight at the scene.  Another much less fancy word for this style of game is “top down”.  Common examples include almost every single game from the 16Bit generation of consoles such as Zelda or MegaMan.

 

One of the first problems you are going to encounter is how do you create your maps?  One very common solution is the Tiled Map Editor which fortunately I just completed a tutorial on!  This tutorial assumes you know how to generate a TMX file, so if you haven’t be sure to go through the linked tutorial.  Fortunately LibGDX makes it very easy to work with TMX files.

 

First things first we need to copy the TMX and any/all tilemap image files used to your assets folder, like so:

image

You may notice unlike earlier tutorials I am currently using IntelliJ.  With the recent switch to Gradle it is much easier to get up and running in IntelliJ and I massively prefer it to Eclipse.  That said, everything I say is equally valid in Eclipse or IntelliJ and when there are differences, I will point them out.  If you want to get started with IntelliJ read here.

 

Alright, back on topic…

 

Now that you have the map and tilesets in your project, let’s jump right in with the code:

 

package com.gamefromscratch;

import com.badlogic.gdx.ApplicationAdapter;
import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.Input;
import com.badlogic.gdx.InputProcessor;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.OrthographicCamera;
import com.badlogic.gdx.graphics.Texture;
import com.badlogic.gdx.maps.tiled.TiledMap;
import com.badlogic.gdx.maps.tiled.TiledMapRenderer;
import com.badlogic.gdx.maps.tiled.TmxMapLoader;
import com.badlogic.gdx.maps.tiled.renderers.OrthogonalTiledMapRenderer;

public class TiledTest extends ApplicationAdapter implements InputProcessor {
    Texture img;
    TiledMap tiledMap;
    OrthographicCamera camera;
    TiledMapRenderer tiledMapRenderer;
    
    @Override
    public void create () {
        float w = Gdx.graphics.getWidth();
        float h = Gdx.graphics.getHeight();

        camera = new OrthographicCamera();
        camera.setToOrtho(false,w,h);
        camera.update();
        tiledMap = new TmxMapLoader().load("MyCrappyMap.tmx");
        tiledMapRenderer = new OrthogonalTiledMapRenderer(tiledMap);
        Gdx.input.setInputProcessor(this);
    }

    @Override
    public void render () {
        Gdx.gl.glClearColor(1, 0, 0, 1);
        Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);
        Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);
        camera.update();
        tiledMapRenderer.setView(camera);
        tiledMapRenderer.render();
    }

    @Override
    public boolean keyDown(int keycode) {
        return false;
    }

    @Override
    public boolean keyUp(int keycode) {
        if(keycode == Input.Keys.LEFT)
            camera.translate(-32,0);
        if(keycode == Input.Keys.RIGHT)
            camera.translate(32,0);
        if(keycode == Input.Keys.UP)
            camera.translate(0,-32);
        if(keycode == Input.Keys.DOWN)
            camera.translate(0,32);
        if(keycode == Input.Keys.NUM_1)
            tiledMap.getLayers().get(0).setVisible(!tiledMap.getLayers().get(0).isVisible());
        if(keycode == Input.Keys.NUM_2)
            tiledMap.getLayers().get(1).setVisible(!tiledMap.getLayers().get(1).isVisible());
        return false;
    }

    @Override
    public boolean keyTyped(char character) {

        return false;
    }

    @Override
    public boolean touchDown(int screenX, int screenY, int pointer, int button) {
        return false;
    }

    @Override
    public boolean touchUp(int screenX, int screenY, int pointer, int button) {
        return false;
    }

    @Override
    public boolean touchDragged(int screenX, int screenY, int pointer) {
        return false;
    }

    @Override
    public boolean mouseMoved(int screenX, int screenY) {
        return false;
    }

    @Override
    public boolean scrolled(int amount) {
        return false;
    }
}

 

When you run the code you should see your map.  Pressing the arrow keys will scroll around the map ( and show bright red when you’ve moved beyond the extents of your map ) .  Pressing 0 or 1 will toggle the visibility of each of the two layers in your map.  ( See the tutorial on Tiled if that makes no sense ).

 

image

 

The impressive thing here is how little code was required to accomplish so much.  In a nutshell it was basically just this:

 

camera = new OrthographicCamera();
camera.setToOrtho(false,w,h);
camera.update();
tiledMap = new TmxMapLoader().load("MyCrappyMap.tmx");
tiledMapRenderer = new OrthogonalTiledMapRenderer(tiledMap);

 

We create an OrthographicCamera, set it to the dimensions of the screen and update() it.  Next we load our map using TmxMapLoader.load() and create a OrthogonalTiledMapRenderer passing in our tiled map.

 

In our render method:

camera.update();
tiledMapRenderer.setView(camera);
tiledMapRenderer.render();

Basically update the camera ( in case we moved it using arrow keys ), pass it in to the TiledMapRenderer with setView() and finally render() the map.  That’s it.

As you can see in our key handler:

 

@Override
public boolean keyUp(int keycode) {
    if(keycode == Input.Keys.LEFT)
        camera.translate(-32,0);
    if(keycode == Input.Keys.RIGHT)
        camera.translate(32,0);
    if(keycode == Input.Keys.UP)
        camera.translate(0,-32);
    if(keycode == Input.Keys.DOWN)
        camera.translate(0,32);
    if(keycode == Input.Keys.NUM_1)
        tiledMap.getLayers().get(0).setVisible(!tiledMap.getLayers().get(0).isVisible());
    if(keycode == Input.Keys.NUM_2)
        tiledMap.getLayers().get(1).setVisible(!tiledMap.getLayers().get(1).isVisible());
    return false;
}

 

Navigating around the map is simply a matter of moving around the camera.  We move in 32pixel chunks because those are the size of our tiles.  So basically we move the camera left/right/up/down by one tile each time an arrow key is pressed.  In the event the 0 or 1 key are pressed we toggle the visibility of that particular layer.  As you can see, you can access the TileMap layers using the getLayers().get() function.

 

In the next part we will look at adding some more complex functionality.

Geeks3D Forums

AMD Catalyst 14.200 with 90% OpenGL 4.4

April 16, 2014 06:14 PM

Driver provided by Computerbase: AMD Catalyst Komplettpaket Beta (14.200.0)

Original link  [url=http://support.amd.com/en-us/kb-articles/P...



Confetti Special FX

Work in Progress: Volumetric Explosions

by Wolfgang at April 16, 2014 06:08 PM

You can find a work in progress movie of Volumetric explosions here:

Work in Progress: Volumetric Explosions

We are still working on the possibilies. If you split up a Michael Bay explosion in phases you can use four:
1. “Lightning” – first part over brightens the scene
2. Glow – this is the glowy part that is still white / yellowish
3. Orange glow + dark smoke
4. Lots of smoke …
We are getting better with 3 but 1 is too faint, 2 is ok and 4 is not enough.ties how to mix 2D and 3D effects … currently most of this are 3D volumetric effects.

Confetti on FMX – Dynamic Global Illumination Presentation

by Wolfgang at April 16, 2014 06:02 PM

We are co-organizing the real-time rendering day on FMX again. So next week we will be in Stuttgart. We will also give a presentation on “Dynamic Global Illumination Systems” on Wednesday. Drop by and say hi!

Geeks3D Forums

NVIDIA GeForce R337.61 BETA Hotfix Display Driver Release - April 16th 2014

April 16, 2014 04:34 PM

Quote
The GeForce R337.61 Hotfix Display Driver is available for download.  This driver is being released by NVIDIA as a hotfix driver to resolve the following issues: 

•         Half...



Review NVIDIA GeForce GTX 860M Maxwell vs. Kepler

April 16, 2014 03:46 PM

Quote
The unequal duel. Nvidia offers two different versions of its latest high-end GPU GeForce GTX 860M. Besides a version based on the Maxwell architecture, there is also a GPU from the old Kepler generation. We compared the performance of the two D...

NVIDIA CUDA 6.037 driver for MAC OS X

April 16, 2014 03:36 PM

Quote
New Release 6.0.37

CUDA driver 6.0.37 is required for CUDA support on Mac OS X 10.9 Mavericks.

 Supports all NVIDIA products available on Mac HW.

I still have no Mac...

iPhone Development Tutorials and Programming Tips

An Open Source iOS In-App Web Page Display Component With An Automatically Adjusting Interface

by Johann at April 16, 2014 02:32 PM

Post Category    Featured iPhone Development Resources,iOS UI Controls,iPad,iPhone,Objective-C

I’ve mentioned a few in app web page browsing components, most recently DZWebBrowser.

Here’s an interesting web view controller from Tim Oliver called TOWebViewController that not only makes it easy to present a web page within your apps but provides some nice unique features.

These features include:

- A navigation bar and icons that adjust based on the iOS version of the user
- Support for iOS 5+
- A full set of browser buttons drawn using core graphics
- An integrated progess bar
- An automatically adjusting interface that adjusts accordingly  if the view is pushed to a UINavigationController or modally

A set of images from the readme showing TOWebViewController running on different iOS versions.
TOWebViewController

You can find TOWebViewController on Github here.

A nice easy way to cleanly display web pages in an app.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: An Open Source iOS In-App Web Page Display Component With An Automatically Adjusting Interface

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.



GPGPU.org

A high throughput efficient approach for decoding LDPC codes onto GPU devices

by dom at April 16, 2014 08:19 AM

Abstract:

LDPC decoding process is known as compute intensive. This kind of digital communication applications was recently implemented onto GPU devices for LDPC code performance estimation and/or for real-time measurements. Overall previous studies about LDPC decoding on GPU were based on the implementation of the flooding-based decoding algorithm that provides massive computation parallelism. More efficient layered schedules were proposed in literature because decoder iteration can be split into sub-layer iterations. These schedules seem to badly fit onto GPU devices due to restricted computation parallelism and complex memory access patterns. However, the layered schedules enable the decoding convergence to speed up by two. In this letter, we show that (a) layered schedule can be efficiently implemented onto a GPU device (b) this approach – implemented onto a low-cost GPU device – provides higher throughputs with identical correction performances (BER) compared to previously published results.

(B. Le Gal, C. Jégo and J. Crenne: “An high-throughput efficiency approach for GPU-based LDPC decoding”. IEEE Embedded System Letters, March 2014. [DOI])

Workshop on GPU Programming for Molecular Modeling, Urbana, IL, July 22-24, 2014

by dom at April 16, 2014 08:15 AM

The GPU Programming for Molecular Modeling workshop will extend GPU programming techniques to the field of molecular modeling, including subjects such as particle-grid algorithms (electrostatics, molecular surfaces, density maps, and molecular orbitals), particle-particle algorithms with an emphasis on non-bonded force calculations, radial distribution functions in GPU histogramming, single-node multi-GPU algorithms, and GPU clusters. Specific examples utilizing the NAMD and VMD software programs will be introduced and discussed in detail. The workshop is designed for researchers in computational and/or biophysical fields who seek to extend their GPU programming skills to include molecular modeling. Advanced lecture sessions will be followed by extended discussion periods between lecturers and participants and laboratory time in which students will be able to work on their own molecular modeling GPU codes. See workshop website for details and application: http://www.ks.uiuc.edu/Training/Workshop/GPU_Jul2014/

iPhone Development Tutorials and Programming Tips

Tutorial: A Step-By-Step Guide On The Basics Of Using The JavaScriptCore Framework On iOS

by Johann at April 16, 2014 06:23 AM

Post Category    Featured iPhone Development Resources,iOS Development Tutorials,Objective-C

I’ve mentioned the iOS JavascriptCore framework – the framework allowing you to directly utilize the same Javascript engine for WebKit.  Previously I pointed out a simple example, and a library to simplify working with JavascriptCore.

Here’s a step-by-step tutorial from Joseph Dixon that provides details on the basics of using JavascriptCore on the iOS platform in which you’ll build a simple contact management app using both Javascript and Objective-C.

Specifically you’ll learn how to:

- Get a JavascriptCore context (JSContext)
- Define and call Javascript functions
- Call your Objective-C code from Javascript
- Work with the JSContext of a UIWebView

You can find the tutorial over on the Big Nerd Ranch blog.

Example code on using JavascriptCore on iOS for the tutorial can be found on Github here.

A nice guide to utilizing JavascriptCore.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Tutorial: A Step-By-Step Guide On The Basics Of Using The JavaScriptCore Framework On iOS

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.



iPhone Development Tutorials and Programming Tips

A Custom UICollectionView Flow Layout Using Customizable Hexagon Shaped Cells

by Johann at April 15, 2014 08:37 PM

Post Category    Featured iPhone Development Resources,iOS UI Controls,iPad,iPhone,Objective-C

I’ve mentioned a number of resources related to custom UICollectionView layouts such as this tutorial on making great looking custom UICollectionView layouts and most recently a flow layout that provides a grid view supporting swipe to select and deselect gestures.

Here’s a custom UICollectionViewFlowLayout that uses hexagonal cells submitted by Cyril Chandelier called CCHexagonFlowLayout.

With CCHexagonFlowLayout you can easily customize the orientation, size and spacing, and add in supplementary views.

Here’s a set of images from the readme showing CCHexagonFlowLayout in portrait and landscape:
CCHexagonFlowLayout

You can find CCHexagonFlowLayout on Github here.

A nice hexagon UICollectionViewFlowLayout.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: A Custom UICollectionView Flow Layout Using Customizable Hexagon Shaped Cells

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

#AltDevBlogADay

Multi-Threaded Programming 3: Locking, Lock-Free, Wait-Free

by Joseph Simons at April 15, 2014 04:23 PM

Now I want to cover the basic terminology used when talking about concurrent algorithms. This will be helpful so that you are familiar with the available techniques you have when you have multiple threads operating together. The term concurrent itself refers to an algorithm that can scale from being synchronous on a single thread to utilizing multiple threads at the same time. The terms I am going to cover also exist independently of any architecture, though the actual implementation will vary due to the underlying hardware differences. I am going to cover them in order of increasing difficulty to implement, so if you are interested in implementing an algorithm of your own, I would suggest starting with the simplest implementation and moving on only as needed.

If you want to read up on other things that I have covered, then here are my previous posts in this series:

 

locking

Locking

In the previous post, we ended with an example of a mutex lock. This is the easiest and most straightforward method available in order to restrict access to a particular area of code for only a single thread at a time. However, as you may have surmised, it will also have the worst performance when dealing with many threads all accessing the same area at once. This is because the threads are restricted to operating serially, so you basically have given up on the performance benefits of using multiple threads for the area where you lock. But if it is an area that is accessed infrequently, or there is only a small chance that multiple threads will be in the locked area at the same time, it can easily be a “good enough” solution.

Locking is a good first step when you are dealing with data that can be read and modified by multiple threads. As we saw with the explanation of caches, when you modify data on one thread that change will quickly propagate to other threads that then read that data. However, the trickiness lies in the fact that these modifications can occur at any point within your algorithm. So by forcing the algorithm to operate in a serial manner we prevent any unexpected changes that can occur and disrupt what we expect to happen.

While debugging mutex locks can be fairly simple (as far as threading problems go), there are several ways that things can go wrong. If you are using locks and find that program has stopped responding, simply pause it and examine it in the debugger. Chances are that one of the following three things has occurred.

The first pitfall you might have fallen into is what is referred to as a deadlock. This occurs when the operation of your program results in such a manner where a lock is obtained but is never released. This causes your program to halt because no further progress can be made because all the threads are waiting on something that is never going to happen.

One cause of this can be due to not acquiring locks in the same manner in different places in your code. So if you acquire Lock A then Lock B in one place and Lock B then Lock A in another, you can get in a situation where one has Lock A locked and tried to lock Lock B, but can’t because Lock B has already been acquired. Since it has Lock A already, the thread that is holding Lock B cannot get it and so never unlocks Lock B. If you acquire the locks always in the Lock A then Lock B direction, then you can prevent this problem from ever occurring.

DeadLockThreads-1

 

Another cause is simply attempting to use the same lock in multiple places, but you have code that calls to lock multiple times without a resulting unlock. You can easily design a re-entrant mutex that can handle this sort of use case if desired, but make sure that this behavior is what you want.

DeadLockThreads-2

 

The final case that I will cover is likely the hardest to ascertain. When you have multiple threads of different priorities, you need to be careful when it comes to sharing locks. If you have a case where there is low priority, medium priority, and high priority thread, and the low and high priority threads both execute in the same critical section, then you need to be wary of priority inversion. If the low priority thread gets the lock, then gets preempted by the high priority thread, then the high priority thread will not be able to acquire the lock. So the execution will then fall to the medium priority thread (assuming the high priority thread isn’t busy waiting). This isn’t just some idealistic fabrication, it happened to the Mars Pathfinder. There are certain techniques that an OS might use, such as random boosting in Windows, that can help avoid this situation for you.

DeadLockThreads-3

 

Lock-Free

When using atomic operations, we are also forcing a linear execution on our program, but in a much smaller scope. However, they do not fall prey to the things that can go wrong when using locks. Therefore, if we are not using any locks, then our program will always be able to advance. If our algorithm is guaranteed to never wait (even if it has to repeat some of its work), then it is considered a lock-free algorithm. Another way of thinking about it is if you were to arbitrarily pause any thread that is in your algorithm, it will not affect any of the other threads in there.

However, when dealing with lock-free algorithms, even though you do not need to worry about deadlocks as described above, you have a whole new set of problems. The main issue when writing code that doesn’t force linear execution for large sections is that almost anything can happen at anytime. When thinking through the code, you have to take into account that any other thread can come along and perform operations, such as changing a variable, adding / removing a node, or reorganizing the data. Because of this, it is common with lock-free algorithms to continuously test the assumptions before performing an action. If the assumed state is incorrect, then lock-free algorithms typically will loop and repeat their work until they can safely proceed. So, if an area of code has low contention, then using locks might actually lead to faster execution.

However, just testing the state isn’t without its caveats. One particularly nasty thing that can happen is known as the ABA problem. The idea here is that even if you are making sure that you are operating on the same address, by testing it with a Compare-And-Swap atomic action, it can still fail. If the address was recycled in some way (such as being deleted than allocated again, or popped then pushed again) then even though it is at the same location, it is not the same data. This can lead to crashes or lost data, and is very difficult to track down due to the fact that it can be extremely rare.

ABAProblem

 

Wait-Free

Now, if you have an algorithm that will never repeat work and will always advance, then you have a wait-free algorithm. Because of their properties, they will always finish in a fixed number of steps. These can be exceedingly difficult to implement and it is rare to actually see them in use, though technically any algorithm can be translated into a wait-free one. Unfortunately, their performance is typically slower than their lock-free counterparts (though sometimes they can beat the lock-free one under certain circumstances). This means that for games, where performance is typically the highest goal and the number of threads is low, lock-free algorithms are generally the best option for highly threaded, time-critical areas.

 

Final Considerations

Never underestimate the power of a “good enough” solution. Because multi-threaded programming carries with it a high chance of hard to detect bugs, a tiny bit of performance tradeoff for a more stable codebase can definitely be worth it. Therefore, it is actually good practice to start with using simple locks to protect shared data. Then, when you are certain that those locks are a bottleneck, investigate into lock-free solutions. Also, because writing good lock-free algorithms can be difficult, it is usually a good idea to keep an eye out for already implemented libraries that you can make use of. These will help reduce  possible implementation errors, since simple tests might fail to catch all the problems that can occur. Especially since the issues can be very dependent on rare, timing specific situations.

It is also a very good idea to redesign your code so that you minimize the areas where multiple threads can interact with each other. This gives you the benefits of parallelism without many the issues that can occur (such as all those described earlier). We will look at ways to do this later in the series, but I wanted the reader to first be familiar with some of the difficulties that can come with multi-threaded programming. That way, if you encounter a situation where you have to worry about multiple threads executing on the same data, you have a good grasp of the problem space going into it.

 

See You Next Time

Next Time

For the next post, we are going to look at a basic locking queue implementation. For the post after that, we will then see a lock-free queue implementation where I will cover why we need to make the changes that we did in order to convert it. For the following post, we will see if we can optimize the lock-free queue further, and some pitfalls to watch out for while doing so. Because of the difficulties with wait-free algorithms and the fact they typically don’t have much real-world benefit, we will not be covering those further.

 

Further Reading

If you want to read some more about locking, lock-free, and wait-free algorithms, feel free to check out the following areas:

Geeks3D Forums

NVIDIA CUDA 6 SDK production release

April 15, 2014 04:08 PM

Quote
5 Powerful New Features in CUDA 6

Today I’m excited to announce the release of CUDA 6, a new version of the CUDA Toolkit that includes some of the most significan...



Real-Time Rendering

Why use WebGL for Graphics Research?

by Eric at April 15, 2014 03:31 PM

guest post by Patrick Cozzi, @pjcozzi.

This isn’t as crazy as it sounds: WebGL has a chance to become the graphics API of choice for real-time graphics research. Here’s why I think so.

An interactive demo is better than a video.

WebGL allows us to embed demos in a website, like the demo for The Compact YCoCg Frame Buffer by Pavlos Mavridis and Georgios Papaioannou. A demo gives readers a better understanding than a video alone, allows them to reproduce performance results on their hardware, and enables them to experiment with debug views like the demo for WebGL Deferred Shading by Sijie Tian, Yuqin Shao, and me. This is, of course, true for a demo written with any graphics API, but WebGL makes the barrier-to-entry very low; it runs almost everywhere (iOS is still holding back the floodgates) and only requires clicking on a link. Readers and reviewers are much more likely to check it out.

WebGL runs on desktop and mobile.

Android devices now have pretty good support for WebGL. This allows us to write the majority of our demo once and get performance numbers for both desktop and mobile. This is especially useful for algorithms that will have different performance implications due to differences in GPU architectures, e.g., early-z vs. tile-based, or network bandwidth, e.g., streaming massive models.

WebGL is starting to expose modern GPU features.

WebGL is based on OpenGL ES 2.0 so it doesn’t expose features like query timers, compute shaders, uniform buffers, etc. However, with some WebGL 2 (based on ES 3.0) features being exposed as extensions, we are getting access to more GPU features like instancing and multiple render targets. Given that OpenGL ES 3.1 will be released this year with compute shaders, atomics, and image load/store, we can expect WebGL to follow. This will allow compute-shader-based research in WebGL, an area where I expect we’ll continue to see innovation. In addition, with NVIDIA Tegra K1, we see OpenGL 4.4 support on mobile, which could ultimately mean more features exposed by WebGL to keep pace with mobile.

Some graphics research areas, such as animation, don’t always need access to the latest GPU features and instead just need a way to visualization their results. Even many of the latest JCGT papers on rendering can be implemented with WebGL and the extensions it exposes today (e.g., “Weighted Blended Order-Independent Transparency“). On the other hand, some research will explore the latest GPU features or use features only available to languages with pointers, for example, using persistent-mapped buffers in Approaching Zero Driver Overhead by Cass Everitt, Graham Sellers, John McDonald, and Tim Foley.

WebGL is faster to develop with.

Coming from C++, JavaScript takes some getting use to (see An Introduction to JavaScript for Sophisticated Programmers by Morgan McGuire), but it has its benefits: lighting-fast iteration times, lots of open-source third-party libraries, some nice language features such as functions as first-class objects and JSON serialization, and some decent tools. Most people will be more productive in JavaScript than in C++ once up to speed.

JavaScript is not as fast as C++, which is a concern when we are comparing a CPU-bound algorithm to previous work in C++. However, for GPU-bound work, JavaScript and C++ are very similar.

Try it.

Check out the WebGL Report to see what extensions your browser supports. If it meets the needs for your next research project, give it a try!

Game From Scratch

A quick look at Tiled. An open source 2D level editor

by Mike@gamefromscratch.com at April 15, 2014 03:07 PM

 

One very common requirement for even the most simple game is a level editor.  The level of sophistication required varies massively from game to game but a lot of the functionality is pretty common.  At the very base level, you need a tool to layout the graphics that make up your world.  Slightly more advanced, you need to define layers, properties and collision volumes.  Often people roll their own solution but you certainly don’t have to.  One very popular 2D level editor is Tiled Map Editor which exports in TMX format, perhaps the most supported 2D game format ( Cocos2D, LOVE, LibGDX and many others all support TMX out of the box ).  As I am going to be writing a tutorial about using tiled maps in LibGDX, I figured I would give a quick introduction to Tiled first.  Keep in mind, we are only going to scratch the very surface of what Tiled is capable of.

 

First off, download and install Tiled.  It has binaries available for Windows and Mac and a source (and daily builds) release available for Linux.  You can download Tiled here.  The documentation is available here.

 

The Tiled UI is pretty straight forward, although it looks quite different across platforms.  Today I will be using the MacOS version.

 

T1

 

A tiled map is fundamentally simple.  You are basically making a grid of tiles.  A tile is a fixed size image within a larger image.  The larger image is called a tile sheet.  It’s somewhat like working with legos to make a level.  Here is an example tilesheet ( taken from here ):

 

Tilesheet

 

It’s a 512x512 image composed of a number of tiles that we are going to paint our level with.

 

Now that we have our tiles, let’s create our map.  Tiled has the ability to create Orthogonal ( straight on or “top down” perspective maps ) or IsoMetric ( angled perspective ).  In this example we are creating a Orthogonal map.  Next you need to decide how many tiles your map consists of in each direction.  Yes, tiled maps are always rectangular in shape.  Finally you need to decide your tile dimensions in pixels.  Looking at the tile map above it isn’t clear how large each tile is, but that is because some of the larger constructs are actually composed of a number of tiles.  You will see how that works in a few seconds, for now simply select 32x32 pixels for tile size and 32x32 tiles for map size.  In real pixel terms, this makes our map 1024 pixels by 1024 pixels.

 

T2

 

Now we need to load our tile set into Tiled. Select Map->New Tileset

 

T3

 

Now in the resulting dialog name it and otherwise we keep the defaults.  Our tile set is made up of 32x32 tiles, so those values work.  The background colour is used if you use a particular colour colour to mark transparency.  In this case we are using the alpha channel to determine transparency, so we don’t need to set a colour value.

 

T4

 

Now if you look at the bottom corner of Tiled you will see a grid of tiles available.  You simply select a tile, then paint in the right window with it.  

 

T5

 

Let’s start by quickly paint our entire map with a grass tile.  Click a grass tile in the tile sets window, like so:

 

T6

 

Now in the left hand window, select the Fill Tool ( or hit F ), then click in the window, and it will be filed with the tile selected filling our level with a nice grass base.

 

T7

 

Now lets say we want to quickly fill in some roads.  The road tile is actually composed of four separate tiles.  This is easily handled in Tiled, simply click the top left tile in the tile set window, then holding SHIFT, click the bottom left, like so:

 

T8

 

Now you can draw with all four tiles at once by simply clicking on the map.  First select the Stamp tool, then draw out the tiles as you desire:

 

T9

 

So, what about the tiles with transparent sections like these ones?

 

T10

 

Well these are designed to be layered over top of other tiles.  Which leads us nicely to layers.  If you have ever used Photoshop or GIMP, you probably already have a pretty good understanding of layering.  Basically layers are drawn over top of lower layers.  So for example, what you draw in Layer 2 is drawn over top of what you draw in Layer 1.  

 

Right now, we only have a single layer, let’s add another one.  In the top menu, select Layer->Add Tile Layer.

 

T12

 

Now in the Layers panel you should see a second layer available.  Clicking the checkbox to the side of the layer shows/hides it’s contents.  Clicking the layer itself makes it active.  Click Tile Layer 2.

 

T11

 

You can now paint “over” the grass and road layer, like so:

T13

 

Congratulations, you’ve just created your first map.  Now we simply save it.  

 

T14

 

 

Next we will take a look at using this map in code in LibGDX.

iPhone Development Tutorials and Programming Tips

Open Source iOS Library Providing A Lightweight GCD Based HTTP Server

by Johann at April 15, 2014 06:26 AM

Post Category    Featured iPhone Development Resources,iOS Development Libraries,Objective-C,Open Source iOS Libraries And Tools

Previously I mentioned the CocoaHTTPServer that provides a simple http server for your apps, and a wrapper and guide for using the mongoose server within your apps.

Here’s an open source iOS library from Pierre-Oliver Latour that provides a lightweight embeddable http web server called GCDWebServer.

GCDWebServer is built with an event-driven design using grand central dispatch, and provides a number of very nice extra features such as JSON parsing and serialization, http compression with gzip and more. There are also extensions providing an interface for uploading/downloading files, and a WEBDAVServer.

You can find GCDWebServer on Github here.

An interesting iOS server library.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: Open Source iOS Library Providing A Lightweight GCD Based HTTP Server

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.



Geeks3D Forums

TechPowerUp GPU-Z v0.7.8

April 14, 2014 11:20 PM

Quote
GPU-Z is a lightweight utility designed to give you all information about your video card and GPU.

Version History

0.7.8


    GPU-Z window can be resized while sensor ...

iPhone Development Tutorials and Programming Tips

An NSString Category For Easily Getting UIColor Selectors By Name Or Value

by Johann at April 14, 2014 11:10 PM

Post Category    Featured iPhone Development Resources,iOS Development Libraries,Objective-C,Open Source iOS Libraries And Tools

Earlier this year I mentioned a UIColor category providing easy access to specific colors using brand names and late last year a uicolor category providing easy access to iOS 7 colors.

Here’s a NSSTring category submitted by Nicolas Goutaland that makes it easier to utilize the aformentioned color libraries adding methods for gathering UIColor selectors using the rgb or rgba values, or name, to NSString. This makes it very easy to load colors from a PLIST file.

Here’s an example from the readme showing different methods, and ways you can represent colors with NSString+Color:

[@"red" representedColor];        // UIColor selector name without suffix
[@"redColor" representedColor];   // UIColor full selector name
[@"#FFEE55" representedColor];    // RGB Hexadecimal code. Prefix with # to force hexadecimal method
[@"FFEE55" representedColor];     // RGB Hexadecimal code. Will also work, but will be checked through a regex first
[@"#eeEEEe77" representedColor];  // RGB and RGBA Hexadecimal code are case insensitive too
[@"roSyBroWn" representedColor];  // Web color case insensitive

[@"FFEE55" colorFromRGBcode];     // Hexadecimal code
[@"red" colorFromName];           // UIColor selector name, without color suffix
[@"redColor" colorFromName];      // UIColor full selector name
[@"red" colorFromName];           // UIColor selector name, without color suffix
[@"roSyBroWn" colorFromName];     // Web color case insensitive

And to work with colors from other UIColor categories such as FPBrandColors you can simply use something like:

[@"Facebook" representedColor];        // UIColor selector name from FPBrandColors
[@"Github" representedColor];          // UIColor selector name from FPBrandColors

You can find NSString-Color on Github here.

A nice add-on for easily getting the right color.


Be the first to comment...

Related Posts:

FacebookTwitterDiggStumbleUponGoogle Plus

Original article: An NSString Category For Easily Getting UIColor Selectors By Name Or Value

©2014 iOS App Dev Libraries, Controls, Tutorials, Examples and Tools. All Rights Reserved.

Game From Scratch

Maya LT 2015 coming to Steam next week

by Mike@gamefromscratch.com at April 14, 2014 07:20 PM

 

This press release just arrived from Autodesk:

 

Autodesk Maya LT 2015 to Launch on Steam

 

Today Autodesk announced that Maya LT 2015 is coming to Steam, Valve's popular entertainment platform. Maya LT brings its powerful animation and modeling feature set to Steam's active community of over 65 million gamers, developers and artists to help them create 3D game assets to personalize their games and bring them into popular Steam titles like "Defense of the Ancients 2" (DoTA 2) or to create assets for use in their own games.

"The Valve community is unique, because it includes a very engaged mix of both gamers and developers working together to mod titles and generate content. We hope Maya LT will further that creative spirit and help a Steam user of any skill level to create high quality 3D game assets," said Frank Delise, imagedirector, games solution, Autodesk. "We're engaging with the community on day one by participating in forums, answering questions and offering custom tutorial content for DoTA 2 fans. We can't wait to try new things with the community and see how they push Maya LT to its limit and beyond."

A unique solution for professionals and hobbyists alike, Maya LT boasts a targeted feature set developed from the ground up for the indie game industry, like powerful modeling tools to help create and alter 3D assets of any size and a simplified workflow with the Unity 3D Engine. When purchased on Steam, developers will have access to a full commercial Maya LT license, allowing assets created in the tool to also be exported for use in any game on PC, console and mobile.

An online entertainment platform, Steam hosts over 2000 games in all genres. Users can not only instantly download and play games, but also create and share content through the Steam Workshop.

Available April 22, 2014, Maya LT term licenses will be available monthly for $50 USD and will be available in select countries. To learn more or purchase the product on Steam, visit: http://store.steampowered.com/app/243580 .

To check out all the custom DoTA 2 content and Maya LT 101 tutorials, visit the Autodesk Steam community hub: http://steamcommunity.com/app/243580/ .

 

Steam is quickly becoming the online hub for game development tools.  Maya LT is becoming much more feature complete from when it was originally released, much of it based on user feedback.