| /* |
| * Copyright 2018 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can |
| * be found in the LICENSE file. |
| * |
| */ |
| |
| #include "transform_stack.h" |
| |
| // |
| // |
| // |
| |
| #include <stdlib.h> |
| #include <math.h> |
| |
| // |
| // |
| // |
| |
| #undef NDEBUG |
| #include <assert.h> |
| |
| // |
| // |
| // |
| |
| #define TS_TRANSFORM_SUFFIX_EVAL(a) a |
| |
| #define TS_TRANSFORM_SUFFIX_CONCAT(func) \ |
| TS_TRANSFORM_SUFFIX_EVAL(func)##TS_TRANSFORM_SUFFIX_EVAL(TS_TRANSFORM_FLOAT_SUFFIX) |
| |
| // |
| // |
| // |
| |
| #define TS_TRANSFORM_SIN(x) TS_TRANSFORM_SUFFIX_CONCAT(sin)(x) |
| #define TS_TRANSFORM_COS(x) TS_TRANSFORM_SUFFIX_CONCAT(cos)(x) |
| #define TS_TRANSFORM_TAN(x) TS_TRANSFORM_SUFFIX_CONCAT(tan)(x) |
| |
| // |
| // |
| // |
| #define TS_TRANSFORM_ZERO ((ts_transform_float_t)0.0) |
| #define TS_TRANSFORM_ONE ((ts_transform_float_t)1.0) |
| #define TS_TRANSFORM_RCP(f) (TS_TRANSFORM_ONE / (f)) |
| |
| |
| // |
| // |
| // |
| |
| union ts_transform_stack_3x3_u |
| { |
| ts_transform_float_t a8[8]; |
| |
| struct { |
| ts_transform_float_t sx; |
| ts_transform_float_t shx; |
| ts_transform_float_t tx; |
| |
| ts_transform_float_t shy; |
| ts_transform_float_t sy; |
| ts_transform_float_t ty; |
| |
| ts_transform_float_t w0; |
| ts_transform_float_t w1; |
| // w2 is always 1.0 |
| }; |
| |
| struct { |
| ts_transform_float_t a; |
| ts_transform_float_t b; |
| ts_transform_float_t c; |
| |
| ts_transform_float_t d; |
| ts_transform_float_t e; |
| ts_transform_float_t f; |
| |
| ts_transform_float_t g; |
| ts_transform_float_t h; |
| // i is always 1.0 |
| }; |
| }; |
| |
| // |
| // |
| // |
| |
| struct ts_transform_stack |
| { |
| uint32_t size; |
| uint32_t count; |
| |
| ts_transform_weakref_t * weakrefs; |
| union ts_transform_stack_3x3_u * transforms; |
| }; |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_resize(struct ts_transform_stack * const ts, uint32_t const size) |
| { |
| ts->size = size; |
| ts->weakrefs = realloc(ts->weakrefs, size * sizeof(*ts->weakrefs)); |
| ts->transforms = realloc(ts->transforms,size * sizeof(*ts->transforms)); |
| } |
| |
| static |
| void |
| ts_transform_stack_ensure(struct ts_transform_stack * const ts) |
| { |
| if (ts->count < ts->size) |
| return; |
| |
| // increase by 50% and by at least 8 |
| ts_transform_stack_resize(ts,ts->size + max(ts->size/2,8)); |
| } |
| |
| // |
| // |
| // |
| |
| struct ts_transform_stack * |
| ts_transform_stack_create(uint32_t const size) |
| { |
| struct ts_transform_stack * ts = malloc(sizeof(*ts)); |
| |
| ts->size = size; |
| ts->count = 0; |
| |
| ts->transforms = NULL; |
| ts->weakrefs = NULL; |
| |
| ts_transform_stack_resize(ts,size); |
| |
| return ts; |
| } |
| |
| void |
| ts_transform_stack_release(struct ts_transform_stack * const ts) |
| { |
| free(ts->transforms); |
| free(ts->weakrefs); |
| |
| free(ts); |
| } |
| |
| // |
| // |
| // |
| |
| uint32_t |
| ts_transform_stack_save(struct ts_transform_stack * const ts) |
| { |
| return ts->count; |
| } |
| |
| void |
| ts_transform_stack_restore(struct ts_transform_stack * const ts, |
| uint32_t const restore) |
| { |
| ts->count = restore; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| union ts_transform_stack_3x3_u * |
| ts_transform_stack_tos(struct ts_transform_stack * const ts) |
| { |
| return ts->transforms + ts->count - 1; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_3x3_u_copy(union ts_transform_stack_3x3_u * const __restrict dst, |
| union ts_transform_stack_3x3_u const * const __restrict src) |
| { |
| *dst = *src; |
| } |
| |
| // |
| // C = A * B |
| // |
| // FIXME -- can save affine vs. projective flags and save a few ops |
| // |
| |
| #define TS_TRANSFORM_MULTIPLY(A,B) \ |
| A->sx * B->sx + A->shx * B->shy + A->tx * B->w0, \ |
| A->sx * B->shx + A->shx * B->sy + A->tx * B->w1, \ |
| A->sx * B->tx + A->shx * B->ty + A->tx, \ |
| A->shy * B->sx + A->sy * B->shy + A->ty * B->w0, \ |
| A->shy * B->shx + A->sy * B->sy + A->ty * B->w1, \ |
| A->shy * B->tx + A->sy * B->ty + A->ty, \ |
| A->w0 * B->sx + A->w1 * B->shy + B->w0, \ |
| A->w0 * B->shx + A->w1 * B->sy + B->w1, \ |
| A->w0 * B->tx + A->w1 * B->ty + TS_TRANSFORM_ONE |
| |
| // |
| // |
| // |
| |
| #define TS_IS_AFFINE(t) ((t->w0 == TS_TRANSFORM_ZERO) && (t->w1 == TS_TRANSFORM_ZERO)) |
| |
| static |
| ts_transform_type_e |
| ts_transform_stack_classify(struct ts_transform_stack * const ts) |
| { |
| union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts); |
| |
| if (TS_IS_AFFINE(t)) |
| return TS_TRANSFORM_TYPE_AFFINE; |
| else |
| return TS_TRANSFORM_TYPE_PROJECTIVE; |
| } |
| |
| // |
| // |
| // |
| |
| ts_transform_float_t * |
| ts_transform_stack_top_transform(struct ts_transform_stack * const ts) |
| { |
| return ts_transform_stack_tos(ts)->a8; |
| } |
| |
| ts_transform_weakref_t * |
| ts_transform_stack_top_weakref(struct ts_transform_stack * const ts) |
| { |
| return ts->weakrefs + ts->count - 1; |
| } |
| |
| // |
| // |
| // |
| |
| void |
| ts_transform_stack_dup(struct ts_transform_stack * const ts) |
| { |
| ts_transform_stack_ensure(ts); |
| |
| union ts_transform_stack_3x3_u * const tos = ts_transform_stack_tos(ts); |
| |
| ts_transform_stack_3x3_u_copy(tos+1,tos); |
| |
| ts->weakrefs[ts->count] = ts->weakrefs[ts->count-1]; |
| |
| ts->count += 1; |
| } |
| |
| void |
| ts_transform_stack_drop(struct ts_transform_stack * const ts) |
| { |
| assert(ts->count >= 1); |
| |
| ts->count -= 1; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_swap_drop(struct ts_transform_stack * const ts) |
| { |
| assert(ts->count >= 2); |
| |
| union ts_transform_stack_3x3_u * const tos = ts_transform_stack_tos(ts); |
| |
| ts_transform_stack_3x3_u_copy(tos-1,tos); |
| |
| ts->weakrefs[ts->count-2] = ts->weakrefs[ts->count-1]; |
| |
| ts->count -= 1; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_store_matrix_8(struct ts_transform_stack * const ts, |
| uint32_t const idx, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const shy, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const ty, |
| ts_transform_float_t const w0, |
| ts_transform_float_t const w1) |
| { |
| union ts_transform_stack_3x3_u * t = ts->transforms + idx; |
| |
| t->sx = sx; |
| t->shx = shx; |
| t->tx = tx; |
| |
| t->shy = shy; |
| t->sy = sy; |
| t->ty = ty; |
| |
| t->w0 = w0; |
| t->w1 = w1; |
| |
| ts->weakrefs[idx] = TS_TRANSFORM_WEAKREF_INVALID; |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_store_matrix(struct ts_transform_stack * const ts, |
| uint32_t const idx, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const shy, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const ty, |
| ts_transform_float_t const w0, |
| ts_transform_float_t const w1, |
| ts_transform_float_t const w2) |
| { |
| if (w2 == TS_TRANSFORM_ONE) |
| { |
| ts_transform_stack_store_matrix_8(ts,idx, |
| sx, shx,tx, |
| shy,sy, ty, |
| w0, w1); |
| } |
| else |
| { |
| // normalize |
| ts_transform_float_t d = TS_TRANSFORM_RCP(w2); |
| |
| ts_transform_stack_store_matrix_8(ts,idx, |
| sx * d, shx * d, tx * d, |
| shy * d, sy * d, ty * d, |
| w0 * d, w1 * d); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| static |
| void |
| ts_transform_stack_push_matrix_8(struct ts_transform_stack * const ts, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const shy, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const ty, |
| ts_transform_float_t const w0, |
| ts_transform_float_t const w1) |
| { |
| ts_transform_stack_ensure(ts); |
| |
| ts_transform_stack_store_matrix_8(ts,ts->count++, |
| sx, shx,tx, |
| shy,sy, ty, |
| w0, w1); |
| } |
| |
| // |
| // |
| // |
| |
| void |
| ts_transform_stack_push_matrix(struct ts_transform_stack * const ts, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const shy, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const ty, |
| ts_transform_float_t const w0, |
| ts_transform_float_t const w1, |
| ts_transform_float_t const w2) |
| { |
| if (w2 == TS_TRANSFORM_ONE) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| sx, shx,tx, |
| shy,sy, ty, |
| w0, w1); |
| } |
| else |
| { |
| // normalize |
| ts_transform_float_t d = TS_TRANSFORM_RCP(w2); |
| |
| ts_transform_stack_push_matrix_8(ts, |
| sx * d, shx * d, tx * d, |
| shy * d, sy * d, ty * d, |
| w0 * d, w1 * d); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| void |
| ts_transform_stack_push_identity(struct ts_transform_stack * const ts) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| 1.0, 0.0, 0.0, |
| 0.0, 1.0, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_affine(struct ts_transform_stack * const ts, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const shy, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const ty) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| sx, shx, tx, |
| shy, sy, ty, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_translate(struct ts_transform_stack * const ts, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const ty) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| 1.0, 0.0, tx, |
| 0.0, 1.0, ty, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_scale(struct ts_transform_stack * const ts, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const sy) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| sx, 0.0, 0.0, |
| 0.0, sy, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_shear(struct ts_transform_stack * const ts, |
| ts_transform_float_t const shx, |
| ts_transform_float_t const shy) |
| { |
| ts_transform_stack_push_matrix_8(ts, |
| 1.0, shx, 0.0, |
| shy, 1.0, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_skew_x(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta) |
| { |
| ts_transform_float_t const tan_theta = TS_TRANSFORM_TAN(theta); // replace with tanpi if available |
| |
| ts_transform_stack_push_matrix_8(ts, |
| 1.0, tan_theta,0.0, |
| 0.0, 1.0, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_skew_y(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta) |
| { |
| ts_transform_float_t const tan_theta = TS_TRANSFORM_TAN(theta); // replace with tanpi if available |
| |
| ts_transform_stack_push_matrix_8(ts, |
| 1.0, 0.0, 0.0, |
| tan_theta, 1.0, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_rotate(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta) |
| { |
| ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available |
| ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available |
| |
| ts_transform_stack_push_matrix_8(ts, |
| cos_theta,-sin_theta, 0.0, |
| sin_theta, cos_theta, 0.0, |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_rotate_xy2(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta, |
| ts_transform_float_t const cx, |
| ts_transform_float_t const cy, |
| ts_transform_float_t const tx, |
| ts_transform_float_t const ty) |
| { |
| ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available |
| ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available |
| |
| ts_transform_stack_push_matrix_8(ts, |
| cos_theta,-sin_theta, tx - (cx * cos_theta) + (cy * sin_theta), |
| sin_theta, cos_theta, ty - (cx * sin_theta) - (cy * cos_theta), |
| 0.0, 0.0); |
| } |
| |
| void |
| ts_transform_stack_push_rotate_xy(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta, |
| ts_transform_float_t const cx, |
| ts_transform_float_t const cy) |
| { |
| ts_transform_stack_push_rotate_xy2(ts,theta,cx,cy,cx,cy); |
| } |
| |
| void |
| ts_transform_stack_push_rotate_scale_xy(struct ts_transform_stack * const ts, |
| ts_transform_float_t const theta, |
| ts_transform_float_t const sx, |
| ts_transform_float_t const sy, |
| ts_transform_float_t const cx, |
| ts_transform_float_t const cy) |
| { |
| ts_transform_float_t const cos_theta = TS_TRANSFORM_COS(theta); // replace with cospi if available |
| ts_transform_float_t const sin_theta = TS_TRANSFORM_SIN(theta); // replace with sinpi if available |
| |
| ts_transform_stack_push_matrix_8(ts, |
| sx*cos_theta,-sx*sin_theta, cx - cx*sx*cos_theta + cy*sy*sin_theta, |
| sy*sin_theta, sy*cos_theta, cy - cy*sy*cos_theta - cx*sx*sin_theta, |
| 0.0, 0.0); |
| } |
| |
| // |
| // See: "Fundamentals of Texture Mapping and Image Warping" by Paul S. Heckbert (1989) |
| // |
| |
| #define DET(a,b,c,d) (a * d - b * c) |
| |
| #define X(v,i) v[i*2] |
| #define Y(v,i) v[i*2+1] |
| |
| // |
| // |
| // |
| |
| ts_transform_type_e |
| ts_transform_stack_adjoint(struct ts_transform_stack * const ts) |
| { |
| union ts_transform_stack_3x3_u * const t = ts_transform_stack_tos(ts); |
| |
| #if 0 |
| // save for determinant |
| ts_transform_float_t const a = t->a; |
| ts_transform_float_t const b = t->b; |
| ts_transform_float_t const c = t->c; |
| #endif |
| |
| ts_transform_stack_store_matrix(ts,ts->count-1, |
| |
| +DET(t->e, t->f, t->h, TS_TRANSFORM_ONE), |
| -DET(t->b, t->c, t->h, TS_TRANSFORM_ONE), |
| +DET(t->b, t->c, t->e, t->f), |
| |
| -DET(t->d, t->f, t->g, TS_TRANSFORM_ONE), |
| +DET(t->a, t->c, t->g, TS_TRANSFORM_ONE), |
| -DET(t->a, t->c, t->d, t->f), |
| |
| +DET(t->d, t->e, t->g, t->h), |
| -DET(t->a, t->b, t->g, t->h), |
| +DET(t->a, t->b, t->d, t->e)); |
| |
| #if 0 |
| // determinant of t |
| ts_transform_float_t const det = a * t->a + b * t->d + c * t->g; |
| #endif |
| |
| return ts_transform_stack_classify(ts); |
| } |
| |
| // |
| // |
| // |
| |
| ts_transform_type_e |
| ts_transform_stack_push_unit_to_quad(struct ts_transform_stack * const ts, |
| ts_transform_float_t const quad[8]) |
| { |
| ts_transform_float_t const x0 = X(quad,0); |
| ts_transform_float_t const y0 = Y(quad,0); |
| |
| ts_transform_float_t const x1 = X(quad,1); |
| ts_transform_float_t const y1 = Y(quad,1); |
| |
| ts_transform_float_t const x2 = X(quad,2); |
| ts_transform_float_t const y2 = Y(quad,2); |
| |
| ts_transform_float_t const x3 = X(quad,3); |
| ts_transform_float_t const y3 = Y(quad,3); |
| |
| ts_transform_float_t sx = x1 - x0; |
| ts_transform_float_t shy = y1 - y0; |
| |
| ts_transform_float_t const dx2 = x3 - x2; |
| ts_transform_float_t const dy2 = y3 - y2; |
| |
| ts_transform_float_t const dx3 = -sx - dx2; |
| ts_transform_float_t const dy3 = -shy - dy2; |
| |
| // if both zero then quad_dst is a parallelogram and affine |
| if ((dx3 == TS_TRANSFORM_ZERO) && (dy3 == TS_TRANSFORM_ZERO)) |
| { |
| ts_transform_float_t const shx = x2 - x1; |
| ts_transform_float_t const sy = y2 - y1; |
| |
| ts_transform_stack_push_matrix_8(ts, |
| sx, shx, x0, |
| shy, sy, y0, |
| 0.0, 0.0); |
| |
| return TS_TRANSFORM_TYPE_AFFINE; |
| } |
| else |
| { |
| ts_transform_float_t const dx1 = x1 - x2; |
| ts_transform_float_t const dy1 = y1 - y2; |
| |
| ts_transform_float_t const wx_den = dx1 * dy2 - dx2 * dy1; |
| |
| if (wx_den == TS_TRANSFORM_ZERO) |
| return TS_TRANSFORM_TYPE_INVALID; |
| |
| ts_transform_float_t const w0_num = dx3 * dy2 - dx2 * dy3; |
| ts_transform_float_t const w1_num = dx1 * dy3 - dx3 * dy1; |
| |
| ts_transform_float_t const w0 = w0_num / wx_den; |
| ts_transform_float_t const w1 = w1_num / wx_den; |
| |
| sx += w0 * x1; |
| ts_transform_float_t const shx = x3 - x0 + w1 * x3; |
| |
| shy += w0 * y1; |
| ts_transform_float_t const sy = y3 - y0 + w1 * y3; |
| |
| ts_transform_stack_push_matrix_8(ts, |
| sx, shx, x0, |
| shy, sy, y0, |
| w0, w1); |
| |
| return TS_TRANSFORM_TYPE_PROJECTIVE; |
| } |
| } |
| |
| // |
| // |
| // |
| |
| ts_transform_type_e |
| ts_transform_stack_push_quad_to_unit(struct ts_transform_stack * const ts, |
| float const quad[8]) |
| { |
| if (ts_transform_stack_push_unit_to_quad(ts,quad) == TS_TRANSFORM_TYPE_INVALID) |
| return TS_TRANSFORM_TYPE_INVALID; |
| |
| return ts_transform_stack_adjoint(ts); |
| } |
| |
| // |
| // |
| // |
| |
| ts_transform_type_e |
| ts_transform_stack_push_quad_to_quad(struct ts_transform_stack * const ts, |
| ts_transform_float_t const quad_src[8], |
| ts_transform_float_t const quad_dst[8]) |
| { |
| if (ts_transform_stack_push_unit_to_quad(ts,quad_dst) == TS_TRANSFORM_TYPE_INVALID) |
| return TS_TRANSFORM_TYPE_INVALID; |
| |
| if (ts_transform_stack_push_quad_to_unit(ts,quad_src) == TS_TRANSFORM_TYPE_INVALID) |
| return TS_TRANSFORM_TYPE_INVALID; |
| |
| ts_transform_stack_multiply(ts); |
| |
| return ts_transform_stack_classify(ts); |
| } |
| |
| // |
| // |
| // |
| |
| ts_transform_type_e |
| ts_transform_stack_push_rect_to_quad(struct ts_transform_stack * const ts, |
| ts_transform_float_t const x0, |
| ts_transform_float_t const y0, |
| ts_transform_float_t const x1, |
| ts_transform_float_t const y1, |
| ts_transform_float_t const quad_dst[8]) |
| { |
| if (ts_transform_stack_push_unit_to_quad(ts,quad_dst) == TS_TRANSFORM_TYPE_INVALID) |
| return TS_TRANSFORM_TYPE_INVALID; |
| |
| ts_transform_stack_push_matrix_8(ts, |
| TS_TRANSFORM_RCP(x1-x0), |
| 0.0, |
| -x0, |
| 0.0, |
| TS_TRANSFORM_RCP(y1-y0), |
| -y0, |
| 0.0, |
| 0.0); |
| |
| ts_transform_stack_multiply(ts); |
| |
| return ts_transform_stack_classify(ts); |
| } |
| |
| // |
| // The second matrix on the stack (TOS[-1]) is post-multiplied by the |
| // top matrix on the stack (TOS[0]). |
| // |
| // The result replaces TOS[0] and TOS[-1] is unmodified. |
| // |
| // The stack effect of concat is: |
| // |
| // | B | | A*B | |
| // | A | | A | |
| // | . | => | . | |
| // | . | | . | |
| // | . | | . | |
| // |
| void |
| ts_transform_stack_concat(struct ts_transform_stack * const ts) |
| { |
| assert(ts->count >= 2); |
| |
| // get A and B |
| union ts_transform_stack_3x3_u const * const B = ts_transform_stack_tos(ts); |
| union ts_transform_stack_3x3_u const * const A = B - 1; |
| |
| ts_transform_stack_store_matrix(ts,ts->count-1,TS_TRANSFORM_MULTIPLY(A,B)); |
| } |
| |
| // |
| // The second matrix on the stack (TOS[-1]) is post-multiplied by the |
| // top matrix on the stack (TOS[0]). |
| // |
| // The result replaces both matrices. |
| // |
| // The stack effect of multiply is: |
| // |
| // | B | | A*B | |
| // | A | | . | |
| // | . | => | . | |
| // | . | | . | |
| // | . | | . | |
| // |
| void |
| ts_transform_stack_multiply(struct ts_transform_stack * const ts) |
| { |
| assert(ts->count >= 2); |
| |
| // get A and B |
| union ts_transform_stack_3x3_u const * const B = ts_transform_stack_tos(ts); |
| union ts_transform_stack_3x3_u const * const A = B - 1; |
| |
| ts_transform_stack_store_matrix(ts,ts->count-- - 2,TS_TRANSFORM_MULTIPLY(A,B)); |
| } |
| |
| // |
| // |
| // |
| |
| void |
| ts_transform_stack_transform_xy(struct ts_transform_stack * const ts, |
| ts_transform_float_t const x, |
| ts_transform_float_t const y, |
| ts_transform_float_t * const xp, |
| ts_transform_float_t * const yp) |
| { |
| union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts); |
| |
| *xp = x * t->sx + y * t->shx + t->tx; |
| *yp = x * t->shy + y * t->sy + t->ty; |
| |
| if (!TS_IS_AFFINE(t)) |
| { |
| ts_transform_float_t const d = TS_TRANSFORM_RCP(x * t->w0 + y * t->w1 + TS_TRANSFORM_ONE); |
| |
| *xp *= d; |
| *yp *= d; |
| } |
| } |
| |
| // |
| // test it! |
| // |
| |
| #ifdef TS_DEBUG |
| |
| #include <stdio.h> |
| |
| #define TS_DEBUG_SCALE 32.0 |
| |
| // |
| // |
| // |
| |
| void |
| ts_transform_stack_tos_debug(struct ts_transform_stack * const ts) |
| { |
| union ts_transform_stack_3x3_u const * const t = ts_transform_stack_tos(ts); |
| |
| printf("{ { %13.5f, %13.5f, %13.5f },\n" |
| " { %13.5f, %13.5f, %13.5f },\n" |
| " { %13.5f, %13.5f, %13.5f } }\n", |
| t->a8[0], |
| t->a8[1], |
| t->a8[2], |
| t->a8[3], |
| t->a8[4], |
| t->a8[5], |
| t->a8[6], |
| t->a8[7], |
| TS_TRANSFORM_ONE); |
| } |
| |
| // |
| // |
| // |
| |
| void |
| ts_debug(struct ts_transform_stack * const ts, |
| ts_transform_float_t const quad[8]) |
| { |
| ts_transform_stack_tos_debug(ts); |
| |
| for (int ii=0; ii<8; ii+=2) |
| { |
| ts_transform_float_t xp,yp; |
| |
| ts_transform_stack_transform_xy(ts, |
| quad[ii],quad[ii+1], |
| &xp,&yp); |
| |
| printf("( %13.2f, %13.2f ) \t-> ( %13.2f, %13.2f )\n", |
| xp,yp,xp/TS_DEBUG_SCALE,yp/TS_DEBUG_SCALE); |
| } |
| } |
| |
| // |
| // |
| // |
| |
| int |
| main(int argc, char * argv[]) |
| { |
| struct ts_transform_stack * const ts = ts_transform_stack_create(32); |
| |
| ts_transform_float_t const w = 1000; |
| ts_transform_float_t const h = 1000; |
| |
| #if 1 |
| ts_transform_stack_push_scale(ts,TS_DEBUG_SCALE,TS_DEBUG_SCALE); |
| |
| // OpenGL'ism |
| ts_transform_stack_push_affine(ts, |
| 1.0f, 0.0f,0.0f, |
| 0.0f,-1.0f,h); |
| // multiply |
| ts_transform_stack_concat(ts); |
| #else |
| ts_transform_stack_push_identity(ts); |
| #endif |
| |
| uint32_t const restore = ts_transform_stack_save(ts); |
| |
| // |
| // |
| // |
| ts_transform_float_t const quad_src[8] = { 0.0f,0.0f, |
| w, 0.0f, |
| w, h, |
| 0.0f,h }; |
| |
| ts_transform_float_t const quad_dst[8] = { 300.0f, 0.0f, |
| w-300.0f, 0.0f, |
| w, h, |
| 0.0f, h }; |
| |
| ts_transform_float_t const quad_tst[8] = { 50, 50, |
| 1550, 50, |
| 1550, 1550, |
| 50, 1550 }; |
| // |
| // RECT TO QUAD |
| // |
| printf("type = %d\n", |
| ts_transform_stack_push_rect_to_quad(ts, |
| 0.0, 0.0, |
| w, h, |
| quad_dst)); |
| ts_transform_stack_concat(ts); |
| |
| ts_debug(ts,quad_src); |
| |
| // |
| // QUAD TO QUAD |
| // |
| ts_transform_stack_restore(ts,restore); |
| |
| printf("type = %d\n", |
| ts_transform_stack_push_quad_to_quad(ts, |
| quad_src, |
| quad_dst)); |
| ts_transform_stack_concat(ts); |
| |
| ts_debug(ts,quad_src); |
| |
| // |
| // DIRECT |
| // |
| ts_transform_stack_restore(ts,restore); |
| |
| ts_transform_stack_push_matrix(ts, |
| 0.87004626f, -0.35519487f, 72.14745f, |
| 0.0f, 0.2600208f, 86.16314f, |
| 0.0f, -0.0029599573f, 1.0f); |
| |
| ts_transform_stack_concat(ts); |
| |
| ts_transform_float_t const quad_foo[8] = { -10, 10, |
| 130, 10, |
| 130, 110, |
| -10, 110 }; |
| |
| ts_debug(ts,quad_foo); |
| |
| return EXIT_SUCCESS; |
| } |
| |
| #endif |
| |
| // |
| // |
| // |
