From 1d441aea4446484342f93fbf315f7f70de8adaf7 Mon Sep 17 00:00:00 2001 From: Tavian Barnes Date: Tue, 23 Mar 2010 01:53:28 -0400 Subject: Implement most vector functions. --- dimension/parse.c | 189 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 187 insertions(+), 2 deletions(-) (limited to 'dimension/parse.c') diff --git a/dimension/parse.c b/dimension/parse.c index 52479ad..4008fcf 100644 --- a/dimension/parse.c +++ b/dimension/parse.c @@ -521,6 +521,17 @@ dmnsn_copy_astnode(dmnsn_astnode astnode) return copy; } +static dmnsn_astnode +dmnsn_new_astnode2(dmnsn_astnode_type type, dmnsn_astnode loc, + dmnsn_astnode n1, dmnsn_astnode n2) +{ + dmnsn_astnode astnode = dmnsn_copy_astnode(loc); + astnode.type = type; + dmnsn_array_push(astnode.children, &n1); + dmnsn_array_push(astnode.children, &n2); + return astnode; +} + /* 5-element vectors */ #define DMNSN_VECTOR_NELEM 5 @@ -676,7 +687,24 @@ dmnsn_eval_unary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) rewrite.type = DMNSN_AST_SQRT; dmnsn_array_push(rewrite.children, &dot); - ret = dmnsn_eval_unary(rewrite, symtable); + ret = dmnsn_eval(rewrite, symtable); + dmnsn_delete_astnode(rewrite); + break; + } + case DMNSN_AST_VNORMALIZE: + { + dmnsn_astnode norm = dmnsn_copy_astnode(astnode); + norm.type = DMNSN_AST_VLENGTH; + ++*rhs.refcount; + dmnsn_array_push(norm.children, &rhs); + + dmnsn_astnode rewrite = dmnsn_copy_astnode(astnode); + rewrite.type = DMNSN_AST_DIV; + ++*rhs.refcount; + dmnsn_array_push(rewrite.children, &rhs); + dmnsn_array_push(rewrite.children, &norm); + + ret = dmnsn_eval(rewrite, symtable); dmnsn_delete_astnode(rewrite); break; } @@ -787,8 +815,14 @@ dmnsn_eval_unary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) dmnsn_make_ast_float(&ret, tanh(n)); break; case DMNSN_AST_VLENGTH: - dmnsn_make_ast_float(&ret, sqrt(3*n*n)); + dmnsn_make_ast_float(&ret, sqrt(3.0*n*n)); break; + case DMNSN_AST_VNORMALIZE: + { + double elem = 1.0/sqrt(DMNSN_VECTOR_NELEM); + dmnsn_make_ast_vector(&ret, elem, elem, elem, elem, elem); + break; + } default: dmnsn_diagnostic(astnode.filename, astnode.line, astnode.col, @@ -888,6 +922,12 @@ dmnsn_eval_unary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) case DMNSN_AST_VLENGTH: dmnsn_make_ast_float(&ret, sqrt(3.0*n*n)); break; + case DMNSN_AST_VNORMALIZE: + { + double elem = 1.0/sqrt(DMNSN_VECTOR_NELEM); + dmnsn_make_ast_vector(&ret, elem, elem, elem, elem, elem); + break; + } default: dmnsn_diagnostic(astnode.filename, astnode.line, astnode.col, @@ -973,6 +1013,14 @@ dmnsn_eval_binary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) dmnsn_delete_astnode(oldlhs); dmnsn_delete_astnode(oldrhs); + if (lhs.type == DMNSN_AST_NONE || rhs.type == DMNSN_AST_NONE) { + ret = dmnsn_copy_astnode(astnode); + ret.type = DMNSN_AST_NONE; + dmnsn_delete_astnode(lhs); + dmnsn_delete_astnode(rhs); + return ret; + } + switch (astnode.type) { case DMNSN_AST_EQUAL: { @@ -1121,6 +1169,78 @@ dmnsn_eval_binary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) ret.type = DMNSN_AST_NONE; break; + case DMNSN_AST_VAXIS_ROTATE: + { + dmnsn_astnode rx, ry, rz; + dmnsn_array_get(lhs.children, 0, &rx); + dmnsn_array_get(lhs.children, 1, &ry); + dmnsn_array_get(lhs.children, 2, &rz); + dmnsn_astnode ax, ay, az; + dmnsn_array_get(rhs.children, 0, &ax); + dmnsn_array_get(rhs.children, 1, &ay); + dmnsn_array_get(rhs.children, 2, &az); + + dmnsn_vector r = dmnsn_new_vector( + rx.type == DMNSN_AST_INTEGER ? *(long *)rx.ptr : *(double *)rx.ptr, + ry.type == DMNSN_AST_INTEGER ? *(long *)ry.ptr : *(double *)ry.ptr, + rz.type == DMNSN_AST_INTEGER ? *(long *)rz.ptr : *(double *)rz.ptr + ); + dmnsn_vector axis = dmnsn_new_vector( + ax.type == DMNSN_AST_INTEGER ? *(long *)ax.ptr : *(double *)ax.ptr, + ay.type == DMNSN_AST_INTEGER ? *(long *)ay.ptr : *(double *)ay.ptr, + az.type == DMNSN_AST_INTEGER ? *(long *)az.ptr : *(double *)az.ptr + ); + + axis = dmnsn_vector_mul(atan(1.0)/45.0, axis); + r = dmnsn_matrix_vector_mul(dmnsn_rotation_matrix(axis), r); + + ret = dmnsn_copy_astnode(astnode); + dmnsn_make_ast_vector(&ret, r.x, r.y, r.z, 0.0, 0.0); + break; + } + case DMNSN_AST_VCROSS: + { + dmnsn_astnode ux, uy, uz; + dmnsn_array_get(lhs.children, 0, &ux); + dmnsn_array_get(lhs.children, 1, &uy); + dmnsn_array_get(lhs.children, 2, &uz); + *ux.refcount += 2; + *uy.refcount += 2; + *uz.refcount += 2; + dmnsn_astnode vx, vy, vz; + dmnsn_array_get(rhs.children, 0, &vx); + dmnsn_array_get(rhs.children, 1, &vy); + dmnsn_array_get(rhs.children, 2, &vz); + *vx.refcount += 2; + *vy.refcount += 2; + *vz.refcount += 2; + + dmnsn_astnode uvx = dmnsn_new_astnode2( + DMNSN_AST_SUB, astnode, + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, uy, vz), + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, uz, vy) + ); + dmnsn_astnode uvy = dmnsn_new_astnode2( + DMNSN_AST_SUB, astnode, + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, uz, vx), + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, ux, vz) + ); + dmnsn_astnode uvz = dmnsn_new_astnode2( + DMNSN_AST_SUB, astnode, + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, ux, vy), + dmnsn_new_astnode2(DMNSN_AST_MUL, astnode, uy, vx) + ); + + dmnsn_astnode rewrite = dmnsn_copy_astnode(astnode); + rewrite.type = DMNSN_AST_VECTOR; + dmnsn_array_push(rewrite.children, &uvx); + dmnsn_array_push(rewrite.children, &uvy); + dmnsn_array_push(rewrite.children, &uvz); + + ret = dmnsn_eval(rewrite, symtable); + dmnsn_delete_astnode(rewrite); + break; + } case DMNSN_AST_VDOT: { dmnsn_astnode rewrite = dmnsn_copy_astnode(astnode); @@ -1155,6 +1275,47 @@ dmnsn_eval_binary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) dmnsn_delete_astnode(rewrite); break; } + case DMNSN_AST_VROTATE: + { + dmnsn_astnode rx, ry, rz; + dmnsn_array_get(lhs.children, 0, &rx); + dmnsn_array_get(lhs.children, 1, &ry); + dmnsn_array_get(lhs.children, 2, &rz); + dmnsn_astnode ax, ay, az; + dmnsn_array_get(rhs.children, 0, &ax); + dmnsn_array_get(rhs.children, 1, &ay); + dmnsn_array_get(rhs.children, 2, &az); + + dmnsn_vector r = dmnsn_new_vector( + rx.type == DMNSN_AST_INTEGER ? *(long *)rx.ptr : *(double *)rx.ptr, + ry.type == DMNSN_AST_INTEGER ? *(long *)ry.ptr : *(double *)ry.ptr, + rz.type == DMNSN_AST_INTEGER ? *(long *)rz.ptr : *(double *)rz.ptr + ); + dmnsn_vector axis = dmnsn_new_vector( + ax.type == DMNSN_AST_INTEGER ? *(long *)ax.ptr : *(double *)ax.ptr, + ay.type == DMNSN_AST_INTEGER ? *(long *)ay.ptr : *(double *)ay.ptr, + az.type == DMNSN_AST_INTEGER ? *(long *)az.ptr : *(double *)az.ptr + ); + + axis = dmnsn_vector_mul(atan(1.0)/45.0, axis); + + r = dmnsn_matrix_vector_mul( + dmnsn_rotation_matrix(dmnsn_new_vector(axis.x, 0.0, 0.0)), + r + ); + r = dmnsn_matrix_vector_mul( + dmnsn_rotation_matrix(dmnsn_new_vector(0.0, axis.y, 0.0)), + r + ); + r = dmnsn_matrix_vector_mul( + dmnsn_rotation_matrix(dmnsn_new_vector(0.0, 0.0, axis.z)), + r + ); + + ret = dmnsn_copy_astnode(astnode); + dmnsn_make_ast_vector(&ret, r.x, r.y, r.z, 0.0, 0.0); + break; + } default: { @@ -1260,9 +1421,19 @@ dmnsn_eval_binary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) case DMNSN_AST_POW: dmnsn_make_ast_float(&ret, pow(l, r)); break; + case DMNSN_AST_VCROSS: + dmnsn_make_ast_integer(&ret, 0); + break; case DMNSN_AST_VDOT: dmnsn_make_ast_integer(&ret, 3*l*r); break; + case DMNSN_AST_VROTATE: + ret.type = DMNSN_AST_VECTOR; + *lhs.refcount += 3; + dmnsn_array_push(ret.children, &lhs); + dmnsn_array_push(ret.children, &lhs); + dmnsn_array_push(ret.children, &lhs); + break; default: dmnsn_diagnostic(astnode.filename, astnode.line, astnode.col, @@ -1393,9 +1564,19 @@ dmnsn_eval_binary(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) case DMNSN_AST_POW: dmnsn_make_ast_float(&ret, pow(l, r)); break; + case DMNSN_AST_VCROSS: + dmnsn_make_ast_integer(&ret, 0); + break; case DMNSN_AST_VDOT: dmnsn_make_ast_float(&ret, 3.0*l*r); break; + case DMNSN_AST_VROTATE: + ret.type = DMNSN_AST_VECTOR; + *lhs.refcount += 3; + dmnsn_array_push(ret.children, &lhs); + dmnsn_array_push(ret.children, &lhs); + dmnsn_array_push(ret.children, &lhs); + break; default: dmnsn_diagnostic(astnode.filename, astnode.line, astnode.col, @@ -1518,6 +1699,7 @@ dmnsn_eval(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) case DMNSN_AST_TANH: case DMNSN_AST_VAL: case DMNSN_AST_VLENGTH: + case DMNSN_AST_VNORMALIZE: return dmnsn_eval_unary(astnode, symtable); case DMNSN_AST_ADD: @@ -1539,7 +1721,10 @@ dmnsn_eval(dmnsn_astnode astnode, dmnsn_symbol_table *symtable) case DMNSN_AST_MOD: case DMNSN_AST_POW: case DMNSN_AST_STRCMP: + case DMNSN_AST_VAXIS_ROTATE: + case DMNSN_AST_VCROSS: case DMNSN_AST_VDOT: + case DMNSN_AST_VROTATE: return dmnsn_eval_binary(astnode, symtable); case DMNSN_AST_TERNARY: -- cgit v1.2.3