Molecular Musings

Development blog of the Molecule Engine

Implementing a semi-automatic structure-of-arrays data container

Posted on October 22, 2013 by Stefan Reinalter

24

In performance-sensitive applications like games it is crucial to access data in a cache-friendly manner. Especially when dealing with a large number of objects of the same type, e.g. individual components in an entity-component-architecture, we should make sure to read as little data as possible. However, simple arrays-of-structures are often not suited for this, with structures-of-arrays yielding better performance. But the latter are not natively supported by the C++ language.

Continue reading →

Input Evaluation SDK available for download

Posted on March 11, 2013 by Stefan Reinalter

Reply

I’m proud to announce that the first evaluation SDK for our input technology is now available! A new version of the core technology has also been released, with some minor additions and improvements.

Check out www.molecular-matters.com for more information on the input library. Further SDKs will follow during the next few months.

Adventures in data-oriented design – Part 2: Hierarchical data

Posted on February 22, 2013 by Stefan Reinalter

28

One task that is pretty common in game development is to transform data according to some sort of hierarchical layout. Today, we want to take a look at probably the most well-known example of such a task: transforming joints according to a skeleton hierarchy.

Continue reading →

Core Evaluation SDK available for download

Posted on November 8, 2012 by Stefan Reinalter

6

After lots of work I’m proud to finally announce that the first evaluation SDK for our core technology is now available!

Check out www.molecular-matters.com for more information on the core library. Further SDKs will follow during the next few months.

Building a load-balanced task scheduler – Part 4: False sharing

Posted on July 9, 2012 by Stefan Reinalter

2

Even though a task scheduler can help with alleviating the burden of having to distribute small pieces of work to different threads, it cannot help preventing a few issues common in multi-threaded programming, especially in multi-processor environments.

Continue reading →

Building a load-balanced task scheduler – Part 3: Parent-child relationships

Posted on April 25, 2012 by Stefan Reinalter

37

Continuing from where we left off last time, this post explains how parent-child relationships are handled inside the task scheduler, and how streaming tasks can be split automatically by the scheduler.

Continue reading →

Building a load-balanced task scheduler – Part 2: Task model

Posted on April 12, 2012 by Stefan Reinalter

15

In this part of the series, we will discuss Molecule’s task model in detail, and have a look at the underlying C++ code and some subleties we need to watch out for, as well as some unique optimization opportunities.

Continue reading →

Building a load-balanced task scheduler – Part 1: Basics

Posted on April 5, 2012 by Stefan Reinalter

13

With multicore hardware becoming the norm in both PC/console-based gaming as well as on mobile platforms, it is crucial to take advantage of every processor core and thread being thrown at us developers. Therefore, it is important to build technology alleviating the task of writing correct, multi-threaded code.

In order to achieve that, this series will try to explain how to build a load-balancing, work-stealing task scheduler.

Continue reading →

volatile != thread synchronization

Posted on March 5, 2012 by Stefan Reinalter

Reply

Everybody knows that writing correct multithreaded code is hard, even when using proper synchronization primitives like mutexes, critical sections, and the likes. (Ab)using the volatile keyword for synchronization purposes makes a programmer’s life even harder – read on if you care to know why, and help spreading the word.

Continue reading →

A content pipeline for fast iteration times

Posted on January 31, 2012 by Stefan Reinalter

14

A fast content pipeline is crucial for today’s engines, allowing the user to quickly iterate on features, assets, etc. Molecule’s content pipeline enables hot-reloading of every asset the engine understands (textures, models, shaders, …), while retaining blazingly fast loading times.

Continue reading →

Baking signals into textures

Posted on December 30, 2011 by Stefan Reinalter

1

Whenever you’re baking signals into texture maps, there’s quite some issues to watch out for, regardless of the signal you’re baking. This post will try to explain issues I ran into while implementing a baking framework.

Continue reading →

A multitude of ray-tracers to choose from

Posted on December 6, 2011 by Stefan Reinalter

7

I’ve recently had the need for a simple ray-tracer since I started working on a precomputed radiance transfer (PRT) baking tool. There’s multitudes of sample code, implementations and SDKs available, so I wanted to share my findings after a bit of research.

Continue reading →

Gamma-correct rendering

Posted on November 21, 2011 by Stefan Reinalter

8

Eventhough gamma-correct rendering is absolutely crucial in order to get good and realistic lighting results, many programmers (sadly) still don’t care about it. Today, I want to show how different the visual results of lighting in gamma-space vs. linear-space actually are, and what you can do about it.

Continue reading →

Singleton is an anti-pattern

Posted on November 11, 2011 by Stefan Reinalter

17

There’s a horrible disease out there, and a lot of programmers – both junior and senior – are affected by it: Singletonitis. Please, let’s help stopping the plague from spreading further by reading and understanding this post.

Continue reading →

Adventures in data-oriented design – Part 1: Mesh data

Posted on November 3, 2011 by Stefan Reinalter

34

Let’s face it, performance on modern processors (be it PCs, consoles or mobiles) is mostly governed by memory access patterns. Still, data-oriented design is considered something new and novel, and only slowly creeps into programmers’ brains, and this really needs to change. Having co-workers fix your code and improving its performance really is no excuse for writing crappy code (from a performance point-of-view) in the first place.

Continue reading →

SIMD’ifying multi-platform math

Posted on October 18, 2011 by Stefan Reinalter

19

Nowadays, with each platform (even mobiles) supporting some sort of SIMD registers and operations, it is crucial for every codebase/engine to fully utilize the underlying SIMD functionality. However, SIMD instruction sets, registers and types vary for each platform, and sometimes between compilers as well.

This blog post explains how a platform-agnostic SIMD implementation can be built, without having to port large portions of the codebase for each new supported platform.

Continue reading →

Wiring physical devices to abstract inputs

Posted on September 29, 2011 by Stefan Reinalter

17

In an earlier post, we discussed different methods of gathering keyboard input in Windows. Today, we will cover how multi-platform and multi-device input can be handled in a straightforward way, showing a very efficient implementation of the underlying parts.

Continue reading →