Small tasks for beginners

There are some tasks that do not require enormous amounts of work or engine knowledge. We try to summarise them here.

Task: Legacy methods in array.h and string.h

Difficulty: 0/5 (anyone could do that)

Following some renaming/refactoring that occurred in trunk/src/lol/base/array.h and trunk/src/lol/base/string.h, some methods only remain here for backwards compatibility. Look for the string “TODO” in these files:

    /* TODO: remove these legacy functions one day */
    inline void Push(T... args) { push(args...); }
    inline void Insert(ptrdiff_t pos, T... args) { insert(pos, args...); }

Each of these methods needs to be removed and all resulting compilation errors fixed. Do not perform a blind search/replace, and pay attention to indentation.

Task: Variadic versions of min() and max()

Difficulty: 2/5 (understand variadic templates and move operator)

The prototypes for min() and max() in trunk/src/lol/base/functions.h are defined as follows:

    static inline T min(T x, T y) { return std::min(x, y); }
    static inline T max(T x, T y) { return std::max(x, y); }

We would like a variadic version that takes an arbitrary number of arguments instead. Maybe something like this:

    template<typename T, typename... Ts>
    static inline T min(T x, T y, Ts&&... z) { ... }

This will allow us to write the following:

float foo = min(x, y, z, w);

Be careful that the code should build with Visual Studio 2013, which is actually the real difficulty here.

Task: rand() for vector types

Difficulty: 2/5 (a lot of template code to read)

We would like to write the following code:

vec4 p1 = rand<vec4>();
vec3 p2 = rand(vec3(-1.f), vec3(1.f));

This involves specialising the following templates from trunk/src/lol/math/rand.h:

template<typename T> static inline T rand();
template<typename T> static inline T rand(T a);
template<typename T> static inline T rand(T a, T b);

Make sure it works for all vec_t<N,T> types, not just vec3 or vec4.

Task: degree 3 polynomial roots

Difficulty: 3/5 (some maths required)

The polynomial class in trunk/src/lol/math/polynomial.h has a roots() method that returns the polynomial roots for degrees ≤ 2.

I’d like to have an implementation for degree 3 polynomials.

Make sure to write unit tests for this code!

Task: switch to C++11 timers

Difficulty: 3/5

C++11 provides a ​high resolution clock type. Replace the platform-dependent code in trunk/src/sys/timer.cpp with portable code from std::chrono.

WIP tasks

Task: switch to C++11 threads (STARTED 2015/04/06 by Touky)

Difficulty: 3/5

C++11 provides ​threads and ​mutexes.

• (DONE) Replace the platform-dependent code in trunk/src/sys/thread.cpp and trunk/src/sys/threadbase.h with portable C++11 code.
• Once it no longer depends on platform-specific code, remove trunk/src/sys/threadbase.h and merge its contents into trunk/src/lol/sys/thread.h.

Finished tasks

Task: matrix inversion that doesn’t suck (DONE 2015/03/04 by guite)

Difficulty: 3/5 (some maths required)

The current implementation of matrix inversion in trunk/src/lol/math/matrix.h is the mediocre cofactor technique. It has factorial complexity which wasn’t a problem when we only had 4×4 matrices (though it was already slightly slow) but is no longer acceptable.

Suggestion:

• rewrite mat_t::inverse() but also mat_t::determinant() and get rid of mat_t::cofactor()
• use Gauss-Jordan elimination in the general case (see trunk/tools/lolremez/matrix.h for a simple implementation
• specialise inversion for 2×2, 3×3 and maybe 4×4 matrices (see ​this page for formulas)

Make sure to write unit tests for this code!