SkMatrix44_Wrapper.c

// matrix 4x4, wraps old SkMatrix44 api around newer M44 api

#define SMAT4(column, row) m44->setRC(row, column
#define GMAT4(column, row) m44->rc(row, column)

#define MAT4TX GMAT4(3, 0)
#define MAT4TY GMAT4(3, 1)
#define MAT4TZ GMAT4(3, 2)

#define MAT4SX GMAT4(0, 0)
#define MAT4SY GMAT4(1, 1)
#define MAT4SZ GMAT4(2, 2)

#define MAT4PX GMAT4(0, 3)
#define MAT4PY GMAT4(1, 3)
#define MAT4PZ GMAT4(2, 3)

#define SWAPMAT4(c1, r1, c2, r2) \
{ \
    SkScalar tmp = GMAT4(c1, r1); \
    SMAT4(c1, r1), GMAT4(c2, r2)); \
    SMAT4(c2, r2), tmp); \
}

void sk_m44_destroy(sk_m44_t* matrix) {
    delete AsM44(matrix);
}

sk_m44_t* sk_m44_new(void) {
    return ToM44(new SkM44(SkM44::Uninitialized_Constructor::kUninitialized_Constructor));
}

sk_m44_t* sk_m44_new_identity(void) {
    return ToM44(new SkM44());
}

sk_m44_t* sk_m44_new_copy(const sk_m44_t* src) {
    return ToM44(new SkM44(AsM44(*src)));
}

sk_m44_t* sk_m44_new_concat(const sk_m44_t* a, const sk_m44_t* b) {
    return ToM44(new SkM44(AsM44(*a), AsM44(*b)));
}

sk_m44_t* sk_m44_new_matrix(const sk_matrix_t* src) {
    return ToM44(new SkM44(AsMatrix(src)));
}

bool sk_m44_equals(sk_m44_t* matrix, const sk_m44_t* other) {
    return *AsM44(matrix) == *AsM44(other);
}

void sk_m44_to_matrix(sk_m44_t* matrix, sk_matrix_t* dst) {
    SkMatrix m = AsM44(matrix)->asM33();
    *dst = ToMatrix(&m);
}

void sk_m44_set_identity(sk_m44_t* matrix) {
    AsM44(matrix)->setIdentity();
}

float sk_m44_get(sk_m44_t* matrix, int row, int col) {
    return AsM44(matrix)->rc(row, col);
}

void sk_m44_set(sk_m44_t* matrix, int row, int col, float value) {
    AsM44(matrix)->setRC(row, col, value);
}

void sk_m44_as_col_major(sk_m44_t* matrix, float* dst) {
    AsM44(matrix)->getColMajor(dst);
}

void sk_m44_as_row_major(sk_m44_t* matrix, float* dst) {
    AsM44(matrix)->getRowMajor(dst);
}

void sk_m44_set_col_major(sk_m44_t* matrix, float* src) {
    *AsM44(matrix) = SkM44::ColMajor(src);
}

void sk_m44_set_row_major(sk_m44_t* matrix, float* src) {
    *AsM44(matrix) = SkM44::RowMajor(src);
}

void sk_m44_set_translate(sk_m44_t* matrix, float dx, float dy, float dz) {
    AsM44(matrix)->setTranslate(dx, dy, dz);
}

void sk_m44_pre_translate(sk_m44_t* matrix, float dx, float dy, float dz) {
    AsM44(matrix)->preTranslate(dx, dy, dz);
}

void sk_m44_post_translate(sk_m44_t* matrix, float dx, float dy, float dz) {
    AsM44(matrix)->postTranslate(dx, dy, dz);
}

void sk_m44_set_scale(sk_m44_t* matrix, float sx, float sy, float sz) {
    AsM44(matrix)->setScale(sx, sy, sz);
}

void sk_m44_pre_scale(sk_m44_t* matrix, float sx, float sy, float sz) {
    AsM44(matrix)->preScale(sx, sy, sz);
}

void sk_m44_set_concat(sk_m44_t* matrix, const sk_m44_t* a, const sk_m44_t* b) {
    AsM44(matrix)->setConcat(AsM44(*a), AsM44(*b));
}

void sk_m44_pre_concat(sk_m44_t* matrix, const sk_m44_t* m) {
    AsM44(matrix)->preConcat(AsM44(*m));
}

void sk_m44_post_concat(sk_m44_t* matrix, const sk_m44_t* m) {
    AsM44(matrix)->postConcat(AsM44(*m));
}

bool sk_m44_invert(sk_m44_t* matrix, sk_m44_t* inverse) {
    return AsM44(matrix)->invert(AsM44(inverse));
}