/// calculate the effect force d_vector calcForce(const d_vector &pos) { d_vector force, offset; force.assign(0.0); if (m_active) { // apply damping to effect values const double mix = 1.0 - m_damping; int i,j; for (i=0; i < 3; i++) { m_origin[i] = m_damping*m_origin[i] + mix*m_neworig[i]; m_addforce[i] = m_damping*m_addforce[i] + mix*m_newadd[i]; for (j=0; j < 3; j++) { m_jacobian[i][j] = m_damping*m_jacobian[i][j] + mix*m_newjacob[i][j]; } } m_cutoff = m_damping*m_cutoff + mix*m_newcut; offset = pos - m_origin; // no force too far away. if (d_length(offset) > m_cutoff) { return force; } // Compute the force, which is the constant force plus // a force that varies as the effector position deviates // from the origin of the force field. The Jacobian // determines how the force changes in different directions // away from the origin (generalizing spring forces of different // magnitudes that constrain the Phantom to the point of the // origin, to a line containing the origin, or to a plane // containing the origin). force = m_addforce; for (i=0; i<3; ++i) { for (j=0; j<3; ++j) { force[i] += offset[j]*m_jacobian[i][j]; } } } return force; }
/* Return the number of elements in a dictionary. */ uint dict_length(const ref * pdref /* t_dictionary */ ) { return d_length(pdref->value.pdict); }
/* Resize a dictionary. */ int dict_resize(ref * pdref, uint new_size, dict_stack_t *pds) { dict *pdict = pdref->value.pdict; gs_ref_memory_t *mem = dict_memory(pdict); uint new_mask = imemory_new_mask(mem); ushort orig_attrs = r_type_attrs(&pdict->values) & (a_all | a_executable); dict dnew; ref drto; int code; if (new_size < d_length(pdict)) { if (!mem->gs_lib_ctx->dict_auto_expand) return_error(gs_error_dictfull); new_size = d_length(pdict); } make_tav(&drto, t_dictionary, r_space(pdref) | a_all | new_mask, pdict, &dnew); dnew.memory = pdict->memory; if ((code = dict_create_contents(new_size, &drto, dict_is_packed(pdict))) < 0) return code; /* * We must suppress the store check, in case we are expanding * systemdict or another global dictionary that is allowed * to reference local objects. */ r_set_space(&drto, avm_local); /* * If we are expanding a permanent dictionary, we must make sure that * dict_put doesn't think this is a second definition for any * single-definition names. This in turn requires that * dstack_dict_is_permanent must be true for the second ("to") * argument of dict_copy_elements, which requires temporarily * setting *pdref = drto. */ if (CAN_SET_PVALUE_CACHE(pds, pdref, mem)) { ref drfrom; drfrom = *pdref; *pdref = drto; dict_copy_elements(&drfrom, pdref, COPY_FOR_RESIZE, pds); *pdref = drfrom; } else { dict_copy_elements(pdref, &drto, 0, pds); } /* Save or free the old dictionary. */ if (ref_must_save_in(mem, &pdict->values)) ref_do_save_in(mem, pdref, &pdict->values, "dict_resize(values)"); else gs_free_ref_array(mem, &pdict->values, "dict_resize(old values)"); if (ref_must_save_in(mem, &pdict->keys)) ref_do_save_in(mem, pdref, &pdict->keys, "dict_resize(keys)"); else gs_free_ref_array(mem, &pdict->keys, "dict_resize(old keys)"); ref_assign(&pdict->keys, &dnew.keys); ref_assign(&pdict->values, &dnew.values); r_store_attrs(&pdict->values, a_all | a_executable, orig_attrs); ref_save_in(dict_memory(pdict), pdref, &pdict->maxlength, "dict_resize(maxlength)"); d_set_maxlength(pdict, new_size); if (pds) dstack_set_top(pds); /* just in case this is the top dict */ return 0; }
/* * Look up a key in a dictionary. Store a pointer to the value slot * where found, or to the (value) slot for inserting. * See idict.h for the possible return values. */ int dict_find(const ref * pdref, const ref * pkey, ref ** ppvalue /* result is stored here */ ) { dict *pdict = pdref->value.pdict; uint size = npairs(pdict); register int etype; uint nidx; ref_packed kpack; uint hash; int ktype; const gs_memory_t *mem = dict_mem(pdict); /* Compute hash. The only types we bother with are strings, */ /* names, and (unlikely, but worth checking for) integers. */ switch (r_type(pkey)) { case t_name: nidx = name_index(mem, pkey); nh: hash = dict_name_index_hash(nidx); kpack = packed_name_key(nidx); ktype = t_name; break; case t_string: /* convert to a name first */ { ref nref; int code; if (!r_has_attr(pkey, a_read)) return_error(gs_error_invalidaccess); code = name_ref(mem, pkey->value.bytes, r_size(pkey), &nref, 1); if (code < 0) return code; nidx = name_index(mem, &nref); } goto nh; case t_real: /* * Make sure that equal reals and integers hash the same. */ { int expt, i; double mant = frexp(pkey->value.realval, &expt); /* * The value is mant * 2^expt, where 0.5 <= mant < 1, * or else expt == mant == 0. */ if (expt < sizeof(long) * 8 || pkey->value.realval == min_long) i = (int)pkey->value.realval; else i = (int)(mant * min_long); /* MSVC 6.00.8168.0 cannot compile this */ hash = (uint)i * 30503; /* with -O2 as a single expression */ } goto ih; case t_integer: hash = (uint)pkey->value.intval * 30503; ih: kpack = packed_key_impossible; ktype = -1; nidx = 0; /* only to pacify gcc */ break; case t_null: /* not allowed as a key */ return_error(gs_error_typecheck); default: hash = r_btype(pkey) * 99; /* yech */ kpack = packed_key_impossible; ktype = -1; nidx = 0; /* only to pacify gcc */ } /* Search the dictionary */ if (dict_is_packed(pdict)) { const ref_packed *pslot = 0; # define found *ppvalue = packed_search_value_pointer; return 1 # define deleted if (pslot == 0) pslot = kp # define missing goto miss # include "idicttpl.h" # undef missing # undef deleted # undef found /* * Double wraparound, dict is full. * Note that even if there was an empty slot (pslot != 0), * we must return dictfull if length = maxlength. */ if (pslot == 0 || d_length(pdict) == d_maxlength(pdict)) return_error(gs_error_dictfull); *ppvalue = pdict->values.value.refs + (pslot - kbot); return 0; miss: /* Key is missing, not double wrap. See above re dictfull. */ if (d_length(pdict) == d_maxlength(pdict)) return_error(gs_error_dictfull); if (pslot == 0) pslot = kp; *ppvalue = pdict->values.value.refs + (pslot - kbot); return 0; } else { ref *kbot = pdict->keys.value.refs; register ref *kp; ref *pslot = 0; int wrap = 0; for (kp = kbot + dict_hash_mod(hash, size) + 2;;) { --kp; if ((etype = r_type(kp)) == ktype) { /* Fast comparison if both keys are names */ if (name_index(mem, kp) == nidx) { *ppvalue = pdict->values.value.refs + (kp - kbot); return 1; } } else if (etype == t_null) { /* Empty, deleted, or wraparound. */ /* Figure out which. */ if (kp == kbot) { /* wrap */ if (wrap++) { /* wrapped twice */ if (pslot == 0) return_error(gs_error_dictfull); break; } kp += size + 1; } else if (r_has_attr(kp, a_executable)) { /* Deleted entry, save the slot. */ if (pslot == 0) pslot = kp; } else /* key not found */ break; } else { if (obj_eq(mem, kp, pkey)) { *ppvalue = pdict->values.value.refs + (kp - kbot); return 1; } } } if (d_length(pdict) == d_maxlength(pdict)) return_error(gs_error_dictfull); *ppvalue = pdict->values.value.refs + ((pslot != 0 ? pslot : kp) - kbot); return 0; } }