void Cdata::calc_neighbours(int i) {
stack<Ctree_node *> nodes_to_search;
Cparticle *_pp;
//cout << "finding neighbours for particle, r="<<ps[i].r<<" and tag="<<ps[i].tag<<endl;
//find neighbours
nodes_to_search.push(get_root_node());
while (!nodes_to_search.empty()) {
Ctree_node *_ptree_node = nodes_to_search.top();
//cout << "Checking for neighbours in node with key="<<_ptree_node->key<<"and centre="<<_ptree_node->centre<<endl;
nodes_to_search.pop();
//check if its a particle node
if ((_pp = _ptree_node->p) != NULL) {
//cout << "its got a particle, r ="<<_pp->r<<"and tag="<<_pp->tag<<endl;
if (ps[i].is_neighbr(*_pp)) {
//cout << "particle is a neighbour, adding to neighbrs list" << endl;
neighbrs[i].push_back(_pp);
}
//check to see if it contains potential neighbours
} else {
vector<Ctree_node *> &_all_daughters = find_daughters(_ptree_node);
for (int j=0;j<_all_daughters.size();j++) {
if (_all_daughters[j]->has_neighbrs(ps[i])) {
nodes_to_search.push(_all_daughters[j]);
}
}
}
//cout << "all done for this one."<<endl<<endl;
}
}
void CharacterCamera::_compute_camera() {
// update the transform with the next proposed transform (camera is 1 logic frame delayed)
/*
float time = get_root_node()->get_frame_time();
Vector3 oldp = accepted.get_origin();
Vector3 newp = proposed.get_origin();
float frame_dist = time *
if (oldp.distance_to(newp) >
*/
float time = get_root_node()->get_frame_time();
if (true) {
if (clip_ray[0].clipped && clip_ray[1].clipped && clip_ray[2].clipped) {
//all have been clipped
proposed.origin=clip_ray[1].clip_pos;
} else {
Vector3 rel=proposed.origin-target_pos;
if (clip_ray[0].clipped && !clip_ray[2].clipped) {
float distance = target_pos.distance_to(clip_ray[0].clip_pos);
real_t amount = 1.0-(distance/clip_len);
amount = CLAMP(amount,0,1);
rel=Matrix3(Vector3(0,1,0)),
rotate_orbit(Vector2(0,autoturn_speed*time*amount));
}
if (clip_ray[2].clipped && !clip_ray[0].clipped) {
float distance = target_pos.distance_to(clip_ray[2].clip_pos);
real_t amount = 1.0-(distance/clip_len);
amount = CLAMP(amount,0,1);
rotate_orbit(Vector2(0,-autoturn_speed*time*amount));
}
}
}
Transform final;
static float pos_ratio = 0.9;
static float rot_ratio = 10;
Vector3 vec1 = accepted.origin;
Vector3 vec2 = proposed.origin;
final.origin = vec2.linear_interpolate(vec1, pos_ratio * time);
static void test_getChildInDirectory_DirectoryIsEmpty() {
before();
GNode *tree = single_folder(TRUE, TRUE);
// THIS IS THE STRUCTURE:
//
// test-dir (7 children)
// ├─ .apa.png
// ├─ .depa.gif
// ├─ bepa.png
// ├─ cepa.jpg
// ├─ epa.png
// ├─┬dir_one (3 children)
// │ ├─ .three.png
// │ ├─ two.jpg
// │ └─┬.secrets (1 children)
// │ └─ img.jpg
// └─┬dir_two (7 children)
// ├─ apa.png
// ├─ bepa.png
// ├─ cepa.png
// ├─┬sub_dir_four (2 children)
// │ ├──subsub (0 children)
// │ └──subsub2 (0 children)
// ├─┬sub_dir_one (3 children)
// │ ├─ img0.png
// │ ├─ img1.png
// │ └─ img2.png
// ├──sub_dir_three (0 children)
// └─┬sub_dir_two (3 children)
// ├─ img0.png
// ├─ img1.png
// ├─ img2.png
// └─ img3.png
char *path0 = get_absolute_path(testdir_path, "/dir_two/sub_dir_four/subsub");
char *path1 = get_absolute_path(testdir_path, "/dir_two/sub_dir_four/subsub/apa.jpg");
GNode *child = get_root_node(tree);
child = g_node_last_child(child);
child = g_node_first_child(child);
child = g_node_next_sibling(child);
child = g_node_next_sibling(child);
child = g_node_next_sibling(child);
child = g_node_first_child(child);
assert_child_is_equal("Get child in directory ─ Last child is subsub", child, path0);
child = get_child_in_directory(child, path1);
assert_tree_is_null("Get child in directory ─ Directory is empty", child);
free(path0);
free(path1);
free_whole_tree(tree);
after();
}
static void test_getChildInDirectory_FindFromFileAndDir_FileExists() {
before();
GNode *tree = single_folder(TRUE, TRUE);
// THIS IS THE STRUCTURE:
//
// test-dir (7 children)
// ├─ .apa.png
// ├─ .depa.gif
// ├─ bepa.png
// ├─ cepa.jpg
// ├─ epa.png
// ├─┬dir_one (3 children)
// │ ├─ .three.png
// │ ├─ two.jpg
// │ └─┬.secrets (1 children)
// │ └─ img.jpg
// └─┬dir_two (7 children)
// ├─ apa.png
// ├─ bepa.png
// ├─ cepa.png
// ├─┬sub_dir_four (2 children)
// │ ├──subsub (0 children)
// │ └──subsub2 (0 children)
// ├─┬sub_dir_one (3 children)
// │ ├─ img0.png
// │ ├─ img1.png
// │ └─ img2.png
// ├──sub_dir_three (0 children)
// └─┬sub_dir_two (3 children)
// ├─ img0.png
// ├─ img1.png
// ├─ img2.png
// └─ img3.png
char *path0 = get_absolute_path(testdir_path, "/bepa.png");
char *path1 = get_absolute_path(testdir_path, "/dir_two");
char *path2 = get_absolute_path(testdir_path, "/dir_two/bepa.png");
GNode *child0 = get_child_in_directory(tree, path0);
GNode *child1 = g_node_last_child(get_root_node(tree));
assert_child_is_equal("Get child in directory ─ Find bepa.png", child0, path0);
assert_child_is_equal("Get child in directory ─ Last child is dir_two", child1, path1);
GNode *child2 = get_child_in_directory(child0, path2);
GNode *child3 = get_child_in_directory(child1, path2);
assert_child_is_equal("Get child in directory ─ From file ─ File exists", child2, path2);
assert_child_is_equal("Get child in directory ─ From subdir ─ File exists", child3, path2);
free(path0);
free(path1);
free(path2);
free_whole_tree(tree);
after();
}
static void test_addNodeInTree_TreesIn() {
before();
GNode *tree = get_tree(SINGLE_FILE, FALSE, FALSE);
GNode *node = get_tree(SINGLE_FILE, FALSE, FALSE);
tree = get_root_node(tree);
node = get_root_node(node);
add_node_in_tree(tree, node);
char* expected = KWHT TESTDIRNAME RESET " (4 children)\n\
├─ bepa.png\n\
├─ cepa.jpg\n\
├─ epa.png\n\
└─┬" KWHT TESTDIRNAME RESET " (3 children)\n\
├─ bepa.png\n\
├─ cepa.jpg\n\
└─ epa.png\n\
";
assert_equals("Add node in tree ─ Tree in tree: F ─ Recursive: F", expected, print_and_free_tree(tree));
after();
}
expr_ptr from_polish( std::string const & str, std::string const & separator = "|" )
{
Lexer lex ( str );
Lexer::token_type token;
expr_ptr root = get_root_node( lex );
if( !lex.eof() ){
for( size_t i = 0; i != root->num_children(); ++i ){
update_current_token( lex, token );
auto what_to_insert = convert_token_to_expression( token );
root->set_children( i, insert_child( what_to_insert, lex, token ) );
}
}
return root;
}
GumboNode* GumboInterface::get_node_from_path(QList<unsigned int> & apath)
{
GumboNode* dest = get_root_node();
foreach(unsigned int childnum, apath) {
if ((dest->type == GUMBO_NODE_ELEMENT) || (dest->type == GUMBO_NODE_TEMPLATE)) {
GumboVector* children = &dest->v.element.children;
if (childnum < children->length) {
dest = static_cast<GumboNode*>(children->data[childnum]);
} else {
break;
}
} else {
break;
}
}
return dest;
}
void CollisionShape::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_SCENE: {
if (get_root_node()->get_editor() && !indicator.is_valid()) {
indicator=VisualServer::get_singleton()->poly_create();
RID mat=VisualServer::get_singleton()->fixed_material_create();
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_UNSHADED, true );
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_WIREFRAME, true );
VisualServer::get_singleton()->material_set_flag( mat, VisualServer::MATERIAL_FLAG_DOUBLE_SIDED, true );
VisualServer::get_singleton()->material_set_line_width( mat, 3 );
VisualServer::get_singleton()->poly_set_material(indicator,mat,true);
update_indicator(indicator);
}
if (indicator.is_valid()) {
indicator_instance=VisualServer::get_singleton()->instance_create2(indicator,get_world()->get_scenario());
VisualServer::get_singleton()->instance_attach_object_instance_ID(indicator_instance,get_instance_ID());
}
volume_changed();
} break;
case NOTIFICATION_EXIT_SCENE: {
if (indicator_instance.is_valid()) {
VisualServer::get_singleton()->free(indicator_instance);
}
volume_changed();
} break;
case NOTIFICATION_TRANSFORM_CHANGED: {
if (indicator_instance.is_valid()) {
VisualServer::get_singleton()->instance_set_transform(indicator_instance,get_global_transform());
}
volume_changed();
} break;
default: {}
}
}
Dictionary ShaderEditor::get_state() const {
#if 0
apply_shaders();
Dictionary state;
Array paths;
int open=-1;
for(int i=0;i<tab_container->get_child_count();i++) {
ShaderTextEditor *ste = tab_container->get_child(i)->cast_to<ShaderTextEditor>();
if (!ste)
continue;
Ref<Shader> shader = ste->get_edited_shader();
if (shader->get_path()!="" && shader->get_path().find("local://")==-1 && shader->get_path().find("::")==-1) {
paths.push_back(shader->get_path());
} else {
const Node *owner = _find_node_with_shader(get_root_node(),shader.get_ref_ptr());
if (owner)
paths.push_back(owner->get_path());
}
if (i==tab_container->get_current_tab())
open=i;
}
if (paths.size())
state["sources"]=paths;
if (open!=-1)
state["current"]=open;
return state;
#endif
return Dictionary();
}
void ShaderEditor::set_state(const Dictionary& p_state) {
#if 0
print_line("setting state..");
if (!p_state.has("sources"))
return; //bleh
Array sources = p_state["sources"];
for(int i=0;i<sources.size();i++) {
Variant source=sources[i];
Ref<Shader> shader;
if (source.get_type()==Variant::NODE_PATH) {
print_line("cain find owner at path "+String(source));
Node *owner=get_root_node()->get_node(source);
if (!owner)
continue;
shader = owner->get_shader();
} else if (source.get_type()==Variant::STRING) {
print_line("loading at path "+String(source));
shader = ResourceLoader::load(source,"Shader");
}
print_line("found shader at "+String(source)+"? - "+itos(shader.is_null()));
if (shader.is_null()) //ah well..
continue;
get_scene()->get_root_node()->call("_resource_selected",shader);
}
if (p_state.has("current"))
tab_container->set_current_tab(p_state["current"]);
#endif
}
bool Cdata::insert(Cparticle &_p) {
Ctree_node *_ptree_node = get_root_node();
//cout << "inserting particle with r="<<_p.r<<" and tag="<<_p.tag<<endl;
//cout << "starting at root node with key="<<_ptree_node->key<<endl;
while (1) {
_ptree_node->updateNodeWithParticle(_p);
Cparticle *_ppexist = _ptree_node->p;
if (_ppexist != NULL) {
Cparticle &_pexist = *_ppexist;
//cout << "this node has a particle. removing particle with r="<<_pexist.r<<"and tag="<<_pexist.tag<<endl;
_ptree_node->p = NULL;
Ctree_node *_pdexist = daughter(_ptree_node,_pexist);
_pdexist->updateNodeWithParticle(_pexist);
Ctree_node *_pdp = daughter(_ptree_node,_p);
_pdp->updateNodeWithParticle(_p);
while (_pdexist==_pdp) {
//cout << "both daughters are the same. going deeper...(key="<<_pdp->key<<")"<<endl;
_pdexist->leaf = false;
_pdexist = daughter(_pdexist,_pexist);
_pdexist->updateNodeWithParticle(_pexist);
_pdp = daughter(_pdp,_p);
_pdp->updateNodeWithParticle(_p);
}
//cout << "found two separate daughters. orig key="<<_pdp->key<<"orig centre="<<_pdp->centre<<". exist key="<<_pdexist->key<<" exist centre="<<_pdexist->centre<<endl;
_pdexist->add_particle(_pexist);
_pdp->add_particle(_p);
return true;
} else if (_ptree_node->leaf) {
//cout << "this node is a leaf. adding particle..."<<endl;
_ptree_node->add_particle(_p);
return true;
}
_ptree_node = daughter(_ptree_node,_p);
//cout << "moving down tree... new key = "<<_ptree_node->key<<" new centre="<<_ptree_node->centre<<endl;
}
}
GumboNode* GumboInterface::get_node_from_qwebpath(QString webpath)
{
QStringList path_pieces = webpath.split(",", QString::SkipEmptyParts);
GumboNode* node = get_root_node();
GumboNode* end_node = node;
for (int i=0; i < path_pieces.count() - 1 ; ++i) {
QString piece = path_pieces.at(i);
QString name = piece.split(" ")[0];
int index = piece.split(" ")[1].toInt();
GumboVector* children = &node->v.element.children;
GumboNode * next_node = NULL;
if (children->length > 0) {
if (path_pieces.at(i+1).startsWith("#text")) {
next_node = static_cast<GumboNode*>(children->data[index]);
} else {
// need to index correct child index when only counting elements
int elnum = -1;
for (unsigned int j=0; j < children->length; j++) {
GumboNode* child = static_cast<GumboNode*>(children->data[j]);
if ((child->type == GUMBO_NODE_ELEMENT) || (child->type == GUMBO_NODE_TEMPLATE)) {
elnum++;
}
if (elnum == index) {
next_node = child;
break;
}
}
}
if (next_node) {
end_node = next_node;
node = next_node;
} else {
break;
}
}
}
return end_node;
}
static void test_addNodeInTree_DuplicateNode() {
before();
char *path = get_absolute_path(testdir_path, "/cepa.jpg");
VnrFile *vnrfile = vnr_file_create_new(path, "cepa.jpg", FALSE);
GNode *node = g_node_new(vnrfile);
GNode *tree = get_tree(SINGLE_FILE, FALSE, FALSE);
tree = get_root_node(tree);
add_node_in_tree(tree, node);
char* expected = KWHT TESTDIRNAME RESET " (3 children)\n\
├─ bepa.png\n\
├─ cepa.jpg\n\
└─ epa.png\n\
";
assert_equals("Add node in tree ─ Duplicate node: F ─ Recursive: F", expected, print_and_free_tree(tree));
free(path);
free_whole_tree(node);
after();
}
static void test_addNodeInTree_TreeIsLeaf() {
before();
char *path = append_strings(testdir_path, "/cepa.jpg");
VnrFile *vnrfile = vnr_file_create_new(path, "cepa.jpg", FALSE);
GNode *node = g_node_new(vnrfile);
GNode *tree = get_tree(SINGLE_FILE, FALSE, FALSE);
tree = get_root_node(tree);
GNode *bepa = assert_forward_iteration(tree, "bepa.png");
add_node_in_tree(bepa, node);
char* expected = KWHT TESTDIRNAME RESET " (3 children)\n\
├─ bepa.png\n\
├─ cepa.jpg\n\
└─ epa.png\n\
";
assert_equals("Add node in tree ─ Tree is leaf ─ No change", expected, print_and_free_tree(tree));
free(path);
free_whole_tree(node);
after();
}
/*
* If root directory is empty - we set default - Yura's - hash and warn
* about it.
* FIXME: we look for only one name in a directory. If tea and yura both
* have the same value - we ask user to send report to the mailing list
*/
uint32_t find_hash_out(struct reiserfs_mount *rmp)
{
int retval;
struct cpu_key key;
INITIALIZE_PATH(path);
struct reiserfs_node *ip;
struct reiserfs_sb_info *sbi;
struct reiserfs_dir_entry de;
uint32_t hash = DEFAULT_HASH;
get_root_node(rmp, &ip);
if (!ip)
return (UNSET_HASH);
sbi = rmp->rm_reiserfs;
do {
uint32_t teahash, r5hash, yurahash;
reiserfs_log(LOG_DEBUG, "make_cpu_key\n");
make_cpu_key(&key, ip, ~0, TYPE_DIRENTRY, 3);
reiserfs_log(LOG_DEBUG, "search_by_entry_key for "
"key(objectid=%d,dirid=%d)\n",
key.on_disk_key.k_objectid, key.on_disk_key.k_dir_id);
retval = search_by_entry_key(sbi, &key, &path, &de);
if (retval == IO_ERROR) {
pathrelse(&path);
return (UNSET_HASH);
}
if (retval == NAME_NOT_FOUND)
de.de_entry_num--;
reiserfs_log(LOG_DEBUG, "name found\n");
set_de_name_and_namelen(&de);
if (deh_offset(&(de.de_deh[de.de_entry_num])) == DOT_DOT_OFFSET) {
/* Allow override in this case */
if (reiserfs_rupasov_hash(sbi)) {
hash = YURA_HASH;
}
reiserfs_log(LOG_DEBUG,
"FS seems to be empty, autodetect "
"is using the default hash");
break;
}
r5hash = GET_HASH_VALUE(r5_hash(de.de_name, de.de_namelen));
teahash = GET_HASH_VALUE(keyed_hash(de.de_name,
de.de_namelen));
yurahash = GET_HASH_VALUE(yura_hash(de.de_name, de.de_namelen));
if (((teahash == r5hash) &&
(GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash)) ||
((teahash == yurahash) &&
(yurahash ==
GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num]))))) ||
((r5hash == yurahash) &&
(yurahash ==
GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num])))))) {
reiserfs_log(LOG_ERR,
"unable to automatically detect hash "
"function. Please mount with -o "
"hash={tea,rupasov,r5}");
hash = UNSET_HASH;
break;
}
if (GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num]))) == yurahash) {
reiserfs_log(LOG_DEBUG, "detected YURA hash\n");
hash = YURA_HASH;
} else if (GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num]))) == teahash) {
reiserfs_log(LOG_DEBUG, "detected TEA hash\n");
hash = TEA_HASH;
} else if (GET_HASH_VALUE(
deh_offset(&(de.de_deh[de.de_entry_num]))) == r5hash) {
reiserfs_log(LOG_DEBUG, "detected R5 hash\n");
hash = R5_HASH;
} else {
reiserfs_log(LOG_WARNING, "unrecognised hash function");
hash = UNSET_HASH;
}
} while (0);
pathrelse(&path);
return (hash);
}
void rise::document::draw(Cairo::RefPtr<Cairo::Context> const &_cr)
{
auto *root = get_root_node();
if(_cr && root) root->draw(_cr);
}
void Cdata::printMe() {
printMe(get_root_node());
}
void Ktree::report_kmer_counts() {
KtreeNode& root = get_root_node();
recurse_through_kmer_counts("", root);
}
ttree_view_node& ttree_view::add_node(const std::string& id
, const std::map<std::string /* widget id */, string_map>& data)
{
return get_root_node().add_child(id, data);
}
void ttree_view::clear()
{
get_root_node().clear();
resize_content(0, -content_grid()->get_size().y);
}
