Archive for the 'software development' Category

Z- or depth-related artefacts in GLSL shaders on iPhone 6/6 Plus

Advertisements

Multiplying Matrices with AVX. For Fun*

(Cross-posted from GitHub)

Having previously tinkered only very briefly, in assembly, I was keen to try my hand at more.

I do best with a practical, defined problem to solve; having used more or less the same unrolled-loop implementation of a 4×4 matrix multiplication I wrote in university, it seemed a good candidate for a 21st Century update, using Advanced Vector Extensions (AVX) which first shipped with Sandy Bridge processors in 2011. Non-trivial, but tractable.

*Performance was never a motivation of this side project – the problem is too small – but there wouldn’t be much point if the output were slower. And it isn’t: on my (Ivy Bridge) Macbook Pro, it executes in half as many cycles as my previous unrolled-loop implementation and in slightly more than two-thirds as many cycles on a Haswell Ultrabook.

But not faster than XMMatrixMultiply.

Using Intel’s Secure Key (RDRAND) in MS Visual C++ 2010

UPDATE (29/05/2016): added a function to use RDRAND to generate a random value within a specified range, and refactored the logic into a static library and wrapped it with a dynamic library for use with P/Invoke.

Among the features added to Intel’s 3rd-Generation Core i* processors is a Digital Random Number Generator (DRNG) backed by an on-die hardware entropy source. This new hardware feature is made available to software via the also-new RDRAND instruction.

If you’re still using the compiler which shipped with Visual C++ 2010, it seems the only way to leverage the DRNG is either via a third-party library (the one available from Intel’s website is, as of writing, broken) or by dipping into assembly programming. Of these the latter comes with a couple of catches: the mnenomic/intrinsic for the instruction is not available for older assemblers/compilers, and the assembly is slightly different for 32- and 64-bit environments.

The sample project illustrates testing whether the host processor supports the RDRAND instruction as well as invoking it (via assembly). When built for 32-bit CPUs, the assembly is inlined; when built for 64-bit CPUs, the assembly is linked in via an exernal module (the 64-bit compiler in Visual Studio 2010 does not support inline assembly).

For the most part, the project simply follows the Software Implementation Guide from Intel. Additionally, it demonstrates invoking the instruction via its opcode, and linking a module implemented in assembly into a VC++ project.

Waveson WindowShade

Waveson WindowShadeOver at Waveson, I’ve put up the first version of Waveson WindowShade.

Waveson WindowShade is a utility for Windows which draws an unobtrusive, translucent shade over the desktop and windows other than the one with which the user is interacting, helping him or her focus on the video they’re watching, the document they’re editing, etc.

All Hail the Mighty PNGCRUSH

Among other things, I develop games for Flashbang Science. Earlier this week, I posted an update to our first game, Tubes.

Tubes

Tubes is Flash-based (written using the Flex SDK), but from very early on we wanted it to appear to integrate seamlessly with the web page in which it is embedded. This was fairly straightforwardly accomplished via CSS positioning and cutting the graphics to match.

But there was a problem under Safari for Windows, as well as both Safari and Google Chrome for OS X: the browser appeared to render the PNG (Portable Network Graphics) images on the page with less contrast than Flash rendered its graphics (which were cut from the same source, using the same tools, etc.), subtly but unmistakeably breaking the illusion of seamlessness.

After much searching, the solution was to use pngcrush to remove the gamma information, embedded ICC profile, and other ancillary colour information from the PNG images which surrounded the game on the page, as follows:

pngcrush -rem cHRM -rem gAMA -rem iCCP -rem sRGB input.png output.png

The above may seem self-evident to designers and others who spend a lot of time working with images on the Web, but this is the post for which I was looking when I searched for safari webkit flash colour difference.

glDrawRangeElements and Vertex Buffer Objects

It’s not clear from the official documentation, but when drawing elements from a vertex buffer (VBO) via a bound index buffer, the sixth and final parameter to glDrawRangeElements – indices – acts as an offset into the index buffer to the index of the first element to be rendered.

Moreover, the offset is given in bytes and not numbers of elements. So if the values in the index buffer are stored as, say, unsigned short integers – GL_UNSIGNED_SHORT – then the offset to the fifth element would be:
4 * sizeof( GLushort )

Quit and start a new game. This counts as a loss in your statistics.

Playing around with the new version of Solitaire bundled with Windows Vista, and I find that, having saved a game (which I was fairly confident of winning – correctly so, it turns out), I find that everytime I restart the program, I am prompted to resume that same game. This, of course, results in a by-now-inevitable victory, each of which counts (seperately) to one’s overall running score.

This is the sort of .. ‘bug’ isn’t the word for it .. side-effect which can be difficult to unearth when you’re putting the software together but upon which a Random Other Person can land within minutes of using the product (if not instantly).



%d bloggers like this: