ccore/include/core/Generic.h

#ifndef CORE_GENERIC_H
#define CORE_GENERIC_H

#include "core/Matrix.h"

#ifdef IMPORT_CORE
#define GENERIC_PAIR(type, name)                                               \
    type:                                                                      \
    name, const type : name

#define GENERIC_FLOAT_VECTOR(a, name)                                          \
    _Generic((a),                                                              \
        GENERIC_PAIR(Vector2*, name##V2),                                      \
        GENERIC_PAIR(Vector3*, name##V3),                                      \
        GENERIC_PAIR(Vector4*, name##V4))

#define GENERIC_VECTOR(a, name)                                                \
    _Generic((a),                                                              \
        GENERIC_PAIR(Vector2*, name##V2),                                      \
        GENERIC_PAIR(Vector3*, name##V3),                                      \
        GENERIC_PAIR(Vector4*, name##V4),                                      \
        GENERIC_PAIR(IntVector2*, name##IV2),                                  \
        GENERIC_PAIR(IntVector3*, name##IV3),                                  \
        GENERIC_PAIR(IntVector4*, name##IV4))

#define GENERIC_FACTOR(b, type, base, factor)                                  \
    type:                                                                      \
    _Generic((b), GENERIC_PAIR(type, base), default: factor)

#define addSet(a, b) GENERIC_VECTOR(a, addSet)(a, b)
#define add(a, b, c) GENERIC_VECTOR(a, add)(a, b, c)
#define subSet(a, b) GENERIC_VECTOR(a, subSet)(a, b)
#define sub(a, b, c) GENERIC_VECTOR(a, sub)(a, b, c)

#define mulSet(a, b)                                                           \
    _Generic((a),                                                              \
        Matrix *: mulSetMatrix,                                                \
        Quaternion *: mulSetQ,                                                 \
        GENERIC_FACTOR(b, Vector2*, mulSetV2, mulSetV2F),                      \
        GENERIC_FACTOR(b, Vector3*, mulSetV3, mulSetV3F),                      \
        GENERIC_FACTOR(b, Vector4*, mulSetV4, mulSetV4F),                      \
        GENERIC_FACTOR(b, IntVector2*, mulSetIV2, mulSetIV2F),                 \
        GENERIC_FACTOR(b, IntVector3*, mulSetIV3, mulSetIV3F),                 \
        GENERIC_FACTOR(b, IntVector4*, mulSetIV4, mulSetIV4F))(a, b)

#define mul(a, b, c)                                                           \
    _Generic((a),                                                              \
        Matrix *: mulMatrix,                                                   \
        Quaternion *: mulQ,                                                    \
        GENERIC_FACTOR(c, Vector2*, mulV2, mulV2F),                            \
        Vector3 *: _Generic((c),                                               \
                 Vector3 *: _Generic((b),                                      \
                          GENERIC_PAIR(Quaternion*, mulQV3),                   \
                          GENERIC_PAIR(Matrix*, mulMatrixV3),                  \
                          default: mulV3),                                     \
                 default: mulV3F),                                             \
        GENERIC_FACTOR(c, Vector4*, mulV4, mulV4F),                            \
        GENERIC_FACTOR(c, IntVector2*, mulIV2, mulIV2F),                       \
        GENERIC_FACTOR(c, IntVector3*, mulIV3, mulIV3F),                       \
        GENERIC_FACTOR(c, IntVector4*, mulIV4, mulIV4F))(a, b, c)

#define divSet(a, b)                                                           \
    _Generic((a),                                                              \
        GENERIC_FACTOR(b, Vector2*, divSetV2, divSetV2F),                      \
        GENERIC_FACTOR(b, Vector3*, divSetV3, divSetV3F),                      \
        GENERIC_FACTOR(b, Vector4*, divSetV4, divSetV4F),                      \
        GENERIC_FACTOR(b, IntVector2*, divSetIV2, divSetIV2F),                 \
        GENERIC_FACTOR(b, IntVector3*, divSetIV3, divSetIV3F),                 \
        GENERIC_FACTOR(b, IntVector4*, divSetIV4, divSetIV4F))(a, b)

#define div(a, b, c)                                                           \
    _Generic((a),                                                              \
        GENERIC_FACTOR(c, Vector2*, divV2, divV2F),                            \
        GENERIC_FACTOR(c, Vector3*, divV3, divV3F),                            \
        GENERIC_FACTOR(c, Vector4*, divV4, divV4F),                            \
        GENERIC_FACTOR(c, IntVector2*, divIV2, divIV2F),                       \
        GENERIC_FACTOR(c, IntVector3*, divIV3, divIV3F),                       \
        GENERIC_FACTOR(c, IntVector4*, divIV4, divIV4F))(a, b, c)

#define invertSet(a) GENERIC_VECTOR(a, invertSet)(a)
#define invert(a, b) GENERIC_VECTOR(a, invert)(a, b)
#define dot(a, b) GENERIC_FLOAT_VECTOR(a, dot)(a, b)
#define squareLength(a) GENERIC_FLOAT_VECTOR(a, squareLength)(a)
#define length(a) GENERIC_FLOAT_VECTOR(a, length)(a)
#define normalize(a) GENERIC_FLOAT_VECTOR(a, normalize)(a)

#define convert(a, b)                                                          \
    _Generic((a),                                                              \
        Vector2 *: convertIV2,                                                 \
        Vector3 *: convertIV3,                                                 \
        Vector4 *: convertIV4,                                                 \
        IntVector2 *: convertV2,                                               \
        IntVector3 *: convertV3,                                               \
        IntVector4 *: convertV4)(a, b)

// #define toStringV2 coreToStringV2
#endif

#endif