IMPDISPLAY_BEGIN_NAMESPACE void WriteOptimizerState::write(WriterAdaptor w) const { IMP::OwnerPointer<Writer> wp(w); for (unsigned int i=0; i< get_number_of_geometries(); ++i) { get_geometry(i)->set_was_used(true); w->add_geometry(get_geometry(i)); } }
static int internal_basicdsk_translate_sector_interleave(floppy_image *floppy, int sector) { const struct basicdsk_geometry *geom = get_geometry(floppy); if (sector >= geom->sectors) return sector; return geom->sector_map[sector]; }
void ModelComponent::addGeometry(OpenSim::Geometry& geom) { extendAddGeometry(geom); // Check that name exists and is unique as it's used to form PathName if (geom.getName().empty()){ bool nameFound = false; int index = 1; while (!nameFound){ std::stringstream ss; // generate candiate name ss << getName() << "_geom_" << index; std::string candidate = ss.str(); bool exists = false; for (int idx = 0; idx < getProperty_geometry().size() && !exists; idx++){ if (get_geometry(idx).getName() == candidate){ exists = true; break; } } if (!exists){ nameFound = true; geom.setName(candidate); } else index++; } } append_geometry(geom); return; }
void GridComponent::on_render(clan::Canvas &canvas, const clan::Rect &update_rect) { set_cliprect(canvas, get_size()); clan::Rect g = get_geometry().get_size(); bool tab_parent = (get_parent_component()->get_tag_name() == "tabpage"); if (tab_parent) { canvas.fill_rect( g, clan::Colorf::whitesmoke); } else { //canvas.fill_rect( g, clan::Colorf::darkgray); canvas.fill_rect( g, clan::Colorf(199/255.0f, 209/255.0f, 224/255.0f)); canvas.fill_rect( boundary, clan::Colorf::lightgrey/*clan::Colorf("E0DFE3")*/); } /* if (!tab_parent) { clan::Draw::line(canvas, (float)boundary.left, (float)boundary.bottom, (float)boundary.right, (float)boundary.bottom, clan::Colorf::black); clan::Draw::line(canvas, (float)boundary.right, (float)boundary.top, (float)boundary.right, (float)boundary.bottom, clan::Colorf::black); // canvas.fill_rect( get_boundary_grabber_se(), clan::Colorf::darkslategray); } */ clan::Rect framebox = part_windowframe.get_content_box(boundary); framebox.translate(-framebox.left, -framebox.top); part_windowframe.render_box(canvas, framebox); reset_cliprect(canvas); }
/* Called in the parent when the forked process dies. Runs the caller's callback, and cleans up. */ static void finalize_cb (XtPointer closure, int *fd, XtIntervalId *id) { grabclient_data *data = (grabclient_data *) closure; Display *dpy = DisplayOfScreen (data->screen); char *name; XRectangle geom = { 0, 0, 0, 0 }; XtRemoveInput (*id); name = get_name (dpy, data->window); get_geometry (dpy, data->window, &geom); data->callback (data->screen, data->window, data->drawable, name, &geom, data->closure); if (name) free (name); fclose (data->read_pipe); if (data->pid) /* reap zombies */ { int status; waitpid (data->pid, &status, 0); data->pid = 0; } memset (data, 0, sizeof (*data)); free (data); }
// transform MCOORD prime primitive velocity to whichcoord whichvel velocity int metp2met2bl(int whichvel, int whichcoord, FTYPE *pr, int ii, int jj) { int k = 0; FTYPE ucon[NDIM]; struct of_geom geom; // which=WHICHVEL // which==0 means supplied the 4-velocity // which==1 means supplied the 3-velocity // which==2 means supplied the relative 4-velocity // if whichcood==PRIMECOORDS, then just pr2ucon and ucon2pr // effectively this results in changing from one primitive velocity to another within PRIMECOORDS // get prime MCOORD geometry get_geometry(ii,jj,CENT,&geom) ; // transform prime MCOORD primitive to prim MCOORD 4-vel if (pr2ucon(WHICHVEL,pr, &geom ,ucon) >= 1) FAILSTATEMENT("init.c:init()", "pr2ucon()", 1); if(whichcoord>=0){ // transform from prime MCOORD 4-vel to non-prime MCOORD 4-vel metptomet(ii,jj,ucon); // transform from non-prime MCOORD to non-prime whichcoord coordtrans(MCOORD,whichcoord,ii,jj,ucon); } // else already in prime // transform from non-prime whichcoord 4-vel to non-prime whichcoord whichvel-velocity gset(0,whichcoord,ii,jj,&geom); ucon2pr(whichvel,ucon,&geom,pr); return(0); }
int avg2_content(int i, int j, int k, MPI_Datatype datatype,void *writebuf) { int pl = 0, l = 0, col = 0; struct of_geom geom; FTYPE X[NDIM],V[NDIM]; FTYPE ftemp; coord(i, j, k, CENT, X); bl_coord(X, V); get_geometry(i, j, k, CENT, &geom); // if you change # of outputted vars, remember to change numcolumns above if(!GAMMIEDUMP){ ftemp=(FTYPE)(i+startpos[1]); myset(datatype,&ftemp,0,1,writebuf); ftemp=(FTYPE)(j+startpos[2]); myset(datatype,&ftemp,0,1,writebuf); ftemp=(FTYPE)(k+startpos[3]); myset(datatype,&ftemp,0,1,writebuf); } myset(datatype,X,1,3,writebuf); myset(datatype,V,1,3,writebuf); myset(datatype,&geom.g,0,1,writebuf); // 10 myset(datatype,tudtavg[i][j][k],0,NUMSTRESSTERMS,writebuf); myset(datatype,atudtavg[i][j][k],0,NUMSTRESSTERMS,writebuf); // 112*2 // total=10+112*2=234 return(0); }
void RadialMenu::on_render(CL_GraphicContext &gc, const CL_Rect &update_rect) { if(selected_index != -1) image_pointer.draw(gc, (float)center_x, (float)center_y); part_component.render_box(gc, get_geometry().get_size(), update_rect); CL_Angle text_angle = CL_Angle::from_degrees(90); for(unsigned int i = 0; i < items.size(); ++i) { float rads = text_angle.to_radians(); if(i == selected_index) { int x = (int)((-cosf(rads)) * selected_text_distance); int y = (int)((-sinf(rads)) * selected_text_distance); int font_center_x = selected_font.get_text_size(gc, items[i].text).width / 2; int font_center_y = (int)selected_font_height / 2; selected_font.draw_text(gc, center_x + x - font_center_x, center_y + y + font_center_y, items[i].text, selected_text_color); } else { int x = (int)((-cosf(rads)) * normal_text_distance); int y = (int)((-sinf(rads)) * normal_text_distance); int fontx = normal_font.get_text_size(gc, items[i].text).width / 2; int fonty = (int)normal_font_height / 2; normal_font.draw_text(gc, center_x + x - fontx, center_y + y + fonty, items[i].text, normal_text_color); } text_angle += CL_Angle::from_degrees(45.0f); } }
void GridObject::save_anchors(clan::DomElement &e, clan::GUIComponent *comp) { clan::Rect boundary = grid_component->get_dialog_size(); clan::GUIComponent *tab_or_frame_parent = get_tab_or_frame_parent(comp); if (tab_or_frame_parent) { boundary = tab_or_frame_parent->get_geometry().get_size(); } clan::Rect g = get_geometry(); clan::Point tl = g.get_top_left(); clan::Point br = g.get_bottom_right(); clan::Point dist_tl = get_dist(anchor_tl, tl, boundary); clan::Point dist_br = get_dist(anchor_br, br, boundary); e.set_attribute("anchor_tl", clan::StringHelp::int_to_text(anchor_tl)); e.set_attribute("anchor_br", clan::StringHelp::int_to_text(anchor_br)); e.set_attribute("dist_tl_x", clan::StringHelp::int_to_text(dist_tl.x)); e.set_attribute("dist_tl_y", clan::StringHelp::int_to_text(dist_tl.y)); e.set_attribute("dist_br_x", clan::StringHelp::int_to_text(dist_br.x)); e.set_attribute("dist_br_y", clan::StringHelp::int_to_text(dist_br.y)); }
int avg_content(int i, int j, int k, MPI_Datatype datatype,void *writebuf) { int pl = 0, l = 0, col = 0; struct of_geom geom; FTYPE X[NDIM],V[NDIM]; FTYPE ftemp; coord(i, j, k, CENT, X); bl_coord(X, V); get_geometry(i, j, k, CENT, &geom); if(!GAMMIEDUMP){ ftemp=(FTYPE)(i+startpos[1]); myset(datatype,&ftemp,0,1,writebuf); ftemp=(FTYPE)(j+startpos[2]); myset(datatype,&ftemp,0,1,writebuf); ftemp=(FTYPE)(k+startpos[3]); myset(datatype,&ftemp,0,1,writebuf); } myset(datatype,X,1,3,writebuf); myset(datatype,V,1,3,writebuf); myset(datatype,&geom.g,0,1,writebuf); // now do time average stuff myset(datatype,normalvarstavg[i][j],0,NUMNORMDUMP,writebuf); myset(datatype,anormalvarstavg[i][j],0,NUMNORMDUMP,writebuf); #if(CALCFARADAYANDCURRENTS) myset(datatype,jcontavg[i][j],0,NDIM,writebuf); myset(datatype,jcovtavg[i][j],0,NDIM,writebuf); myset(datatype,ajcontavg[i][j],0,NDIM,writebuf); myset(datatype,ajcovtavg[i][j],0,NDIM,writebuf); #endif myset(datatype,massfluxtavg[i][j],0,NDIM,writebuf); myset(datatype,amassfluxtavg[i][j],0,NDIM,writebuf); myset(datatype,othertavg[i][j],0,NUMOTHER,writebuf); myset(datatype,aothertavg[i][j],0,NUMOTHER,writebuf); #if(CALCFARADAYANDCURRENTS) myset(datatype,fcontavg[i][j],0,NUMFARADAY,writebuf); myset(datatype,fcovtavg[i][j],0,NUMFARADAY,writebuf); myset(datatype,afcontavg[i][j],0,NUMFARADAY,writebuf); myset(datatype,afcovtavg[i][j],0,NUMFARADAY,writebuf); #endif #if(DOAVG2==0) myset(datatype,tudtavg[i][j],0,NUMSTRESSTERMS,writebuf); myset(datatype,atudtavg[i][j],0,NUMSTRESSTERMS,writebuf); #endif return(0); }
// Description: returns the requested field, computing it if it is not // already in the cache. You MUST call release_field() on the returned field // when you don't need it any more... // See also class Field_Id const LataField_base & LataFilter::get_field(const Field_Id & id) { Journal(filter_info_level) << "LataFilter::get_field " << id.uname_ << " time=" << id.timestep_ << " bloc=" << id.block_ << endl; data_cache_.cleanup_cache(id.timestep_); const LataFieldMetaData & field_metadata = get_field_metadata(id.uname_); LataDeriv<LataField_base> & field_ptr = get_cached_field(id); if (!field_ptr.non_nul()) { if (field_metadata.source_ == "latadb") { // Request for a native field : load it from lataDB const Domain & dom = get_geometry(id); dom.fill_field_from_lataDB(lataDB(), id, field_ptr); release_geometry(dom); } else if (field_metadata.source_.debute_par("OPERATOR")) { const Field_Id src_id(field_metadata.source_field_, id.timestep_, id.block_); const Domain & src_domain = get_geometry(src_id); const LataField_base & src_field = get_field(src_id); const Domain & dest_domain = get_geometry(id); Operator & op = get_set_operator(dest_domain.id_); op.build_field(src_domain, src_field, dest_domain, field_ptr); field_ptr.valeur().id_ = Field_Id(field_metadata.uname_, src_field.id_.timestep_, src_field.id_.block_); release_field(src_field); release_geometry(src_domain); release_geometry(dest_domain); release_cached_operator(dest_domain.id_); } else if (field_metadata.source_ == "user_fields") { Field<FloatTab> & f = field_ptr.instancie(Field<FloatTab> ); f = user_fields_.valeur().get_field(id); // Force field id to correct value: f.id_ = id; f.component_names_ = field_metadata.component_names_; f.nature_ = field_metadata.is_vector_ ? LataDBField::VECTOR : LataDBField::SCALAR; f.localisation_ = field_metadata.localisation_; } } return field_ptr.valeur(); }
bool DrawApp::OnCmdLineParsed(wxCmdLineParser &parser) { wxString geometry; /* Reads program geometry (X style) */ x = y = width = height = -1; /* Read 'geometry' option. */ if (parser.Found(_T("geometry"), &geometry)) get_geometry(geometry, &x, &y, &width, &height); if (parser.Found(_T("v"))) wxLog::SetVerbose(); m_full_screen = parser.Found(_T("f")); m_just_print_version = parser.Found(_("V")); parser.Found(_T("base"), &m_base); parser.Found(_T("url"), &m_url); m_show_logparams = parser.Found(_T("activity")); m_url_open_in_existing = parser.Found(_T("e")); if (m_base.IsEmpty()) for (size_t i = 0; i < parser.GetParamCount(); ++i) { wxString arg = parser.GetParam(i); if (arg.StartsWith(_T("draw://"))) { m_url = arg; break; } } long debug; if (parser.Found(_T("debug"), &debug)) sz_loginit((int) debug, "draw3", SZ_LIBLOG_FACILITY_APP); else sz_loginit(2, "draw3", SZ_LIBLOG_FACILITY_APP); if (parser.Found(_T("4"))) m_base_type = SZ4_BASE; if (parser.Found(_T("i"))) { m_base_type = IKS_BASE; if (!parser.Found(_T("iks-server"), &m_iks_server)) m_iks_server = m_base; parser.Found(_T("iks-server-port"), &m_iks_port); } return true; }
void ToolTip::set_text(const std::string &text) { impl->text = text; Point top_left = get_geometry().get_top_left(); Canvas canvas = get_canvas(); Size text_size = get_render_text_size(canvas, impl->text); Rect rect(Point(0,0), text_size); set_geometry(Rect(top_left, impl->tooltip->get_size())); }
static floperr_t basicdsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length) { sector_index += get_geometry(floppy)->first_sector_id; if (cylinder) *cylinder = track; if (side) *side = head; if (sector) *sector = sector_index; return basicdsk_get_sector_length(floppy, head, track, sector_index, sector_length); }
void GridObject::save_geometry(clan::DomElement &e, clan::GUIComponent *comp) { clan::Rect object_g = comp->get_parent_component()->get_geometry(); clan::Rect g = get_geometry(); std::string left = clan::StringHelp::int_to_text(g.left); std::string right = clan::StringHelp::int_to_text(g.right); std::string top = clan::StringHelp::int_to_text(g.top); std::string bottom = clan::StringHelp::int_to_text(g.bottom); e.set_attribute("geom", left + "," + top + "," + right + "," + bottom); }
static floperr_t basicdsk_get_sector_length(floppy_image *floppy, int head, int track, int sector, UINT32 *sector_length) { floperr_t err; err = get_offset(floppy, head, track, sector, FALSE, NULL); if (err) return err; if (sector_length) *sector_length = get_geometry(floppy)->sector_length; return FLOPPY_ERROR_SUCCESS; }
gboolean configure_event_cb(GtkWidget* window, GdkEventConfigure* event) { (void) window; (void) event; gchar *last_geo = uzbl.gui.geometry; gchar *current_geo = get_geometry(); if(!last_geo || strcmp(last_geo, current_geo)) send_event(GEOMETRY_CHANGED, NULL, TYPE_STR, current_geo, NULL); g_free(current_geo); return FALSE; }
Panel3D::Panel3D(clan::GUIManager &manager) : clan::GUIComponent(&manager, clan::GUITopLevelDescription("3D Controls", clan::Rect(128, 300, clan::Size(320, 448)), false), "window") { clan::Rect client_area = get_geometry(); int xoffset = client_area.left + 10; int yoffset = client_area.top + 10; int gap = 32; checkbox_animate = new clan::CheckBox(this); checkbox_animate->set_geometry(clan::Rect(xoffset, yoffset, clan::Size(128, 40))); checkbox_animate->set_text("Animated GUI"); checkbox_animate->set_checked(true); yoffset += gap; set_control_group(xoffset, yoffset, slider_zoffset, spin_zoffset, label_zoffset, "Z Offset", 1.5f, 4.6f, 0.2f, 3.5f); yoffset += gap; set_control_group(xoffset, yoffset, slider_light_position_x, spin_light_position_x, label_light_position_x, "Light Position X", 0.0f, 1.0f, 0.1f, 0.5f); yoffset += gap; set_control_group(xoffset, yoffset, slider_light_position_y, spin_light_position_y, label_light_position_y, "Light Position Y", 0.0f, 1.0f, 0.1f, 0.5f); yoffset += gap; set_control_group(xoffset, yoffset, slider_light_position_z, spin_light_position_z, label_light_position_z, "Light Position Z", 0.0f, 1.0f, 0.1f, 0.0f); yoffset += gap; set_control_group(xoffset, yoffset, slider_light_specular, spin_light_specular, label_light_specular, "Light Specular", 0.0f, 1.0f, 0.1f, 0.8f); yoffset += gap; set_control_group(xoffset, yoffset, slider_light_diffuse, spin_light_diffuse, label_light_diffuse, "Light Diffuse", 0.0f, 1.0f, 0.1f, 0.8f); yoffset += gap; set_control_group(xoffset, yoffset, slider_material_shininess, spin_material_shininess, label_material_shininess, "Material Shininess", 0.0f, 1.0f, 0.1f, 0.4f); yoffset += gap; set_control_group(xoffset, yoffset, slider_material_emission, spin_material_emission, label_material_emission, "Material Emission", 0.0f, 1.0f, 0.1f, 0.2f); yoffset += gap; set_control_group(xoffset, yoffset, slider_material_specular, spin_material_specular, label_material_specular, "Material Specular", 0.0f, 1.0f, 0.1f, 0.0f); yoffset += gap; set_control_group(xoffset, yoffset, slider_material_transparency, spin_material_transparency, label_material_transparency, "Material Transparency", 0.0f, 1.0f, 0.1f, 0.0f); }
box2d<double> envelope() const { box2d<double> result; for (unsigned i=0;i<num_geometries();++i) { geometry2d const& geom = get_geometry(i); if (i==0) { box2d<double> box = geom.envelope(); result.init(box.minx(),box.miny(),box.maxx(),box.maxy()); } else { result.expand_to_include(geom.envelope()); } } return result; }
// Shows the inventory void show_inventory(void) { WINDOW * w_inv; COORDS co; int t_freeze; w_inv = create_win(0, 0, 0, 0, 1, CP_WHITEBLUE); co = get_geometry(w_inv); set_winstr(w_inv, (co.x - (int) strlen("INVENTORY")) / 2, 1, A_BOLD, CP_WHITEBLUE, "INVENTORY"); t_freeze = pause_game(); set_inputmode(IM_KEYPRESS); getch(); rm_win(w_inv); resume_game(t_freeze); }
static floperr_t basicdsk_format_track(floppy_image *floppy, int head, int track, option_resolution *params) { floperr_t err = FLOPPY_ERROR_SUCCESS; UINT8 local_buffer[512]; void *alloc_buffer = NULL; void *buffer; UINT32 sector_length; int sector; const struct basicdsk_geometry *geometry; geometry = get_geometry(floppy); sector_length = geometry->sector_length; if (sector_length > sizeof(local_buffer)) { alloc_buffer = malloc(sector_length); if (!alloc_buffer) { err = FLOPPY_ERROR_OUTOFMEMORY; goto done; } buffer = alloc_buffer; } else { alloc_buffer = NULL; buffer = local_buffer; } memset(buffer, floppy_get_filler(floppy), sector_length); for (sector = 0; sector < geometry->sectors; sector++) { err = basicdsk_write_sector(floppy, head, track, sector + geometry->first_sector_id, buffer, sector_length); if (err) goto done; } done: if (alloc_buffer) free(alloc_buffer); return err; }
int main(int argc, char**argv) { vec3 a = {0,0,1},b={0,1,0},c; c = vcross(b,a); printf( "C = %f, %f, %f\n\n",c.x,c.y,c.z); const char*out_file,*in_file; //open up enter root element if ( argc < 3 ) return printf( " Sorry, too few args.\n" ),-1; in_file = argv[1]; out_file = argv[2]; TiXmlDocument doc(in_file); if(!doc.LoadFile())//doc.Error()==1) return printf("ERR: %s\n", doc.ErrorDesc()), -1; TiXmlElement*root=doc.RootElement(); if(!root) return printf("Root not found\n"),-1; //MATERIAL NAMES //get_material_names(root); //READ LIGHTS get_lights(root); //READ GEO (polys) get_geometry(root); //Convert to poly / vertex format dae_geo_to_polys_and_verts( dae_geo_objects[0] ); //... nau... do lighting calculations (simple at first render_vertex_colors(); convert(); write(out_file); // render(); return 0; }
void Toolbar::on_render(CL_GraphicContext &gc, const CL_Rect &update_rect) { part_component.render_box(gc, get_geometry().get_size(), update_rect); int pos_x = start_x; int pos_y = start_y; for(unsigned int i = 0; i < items.size(); ++i) { if(i == clicked_index) items[i].icon_clicked.draw(gc, (float)pos_x, (float)pos_y); else if(i == selected_index) items[i].icon_selected.draw(gc, (float)pos_x, (float)pos_y); else items[i].icon.draw(gc, (float)pos_x, (float)pos_y); pos_x += offset_x; } }
// converts whichvel/whichcoord velocity to WHICHVEL/MCOORD int bl2met2metp2v(int whichvel, int whichcoord, FTYPE *pr, int ii, int jj) { int k = 0; FTYPE ucon[NDIM]; struct of_geom geom; // whichvel==0 means supplied the 4-velocity // whichvel==1 means supplied the 3-velocity // whichvel==2 means supplied the relative 4-velocity // if whichcoord==PRIMECOORDS, then really use uses pr2ucon and ucon2pr, could probably optimize if wanted // effectively this results in changing from one primitive velocity to another within PRIMECOORDS // pr is in whichcoord coordinates // get geometry (non-prime coords) gset(0,whichcoord,ii,jj,&geom); // convert whichvel-pr in whichcoord coords to ucon in whichcoord coordinates if (pr2ucon(whichvel,pr, &geom ,ucon) >= 1) FAILSTATEMENT("init.c:init()", "pr2ucon()", 1); // convert from whichcoord to MCOORD, the coordinates of evolution if(whichcoord>=0){ coordtrans(whichcoord,MCOORD,ii,jj,ucon); // transform MCOORD ucon from MCOORD non-prime to MCOORD prime coords mettometp(ii,jj,ucon); } // otherwise already in prime // get prime geometry get_geometry(ii,jj,CENT,&geom) ; // convert from MCOORD prime 4-vel to MCOORD prime WHICHVEL-vel(i.e. primitive velocity of evolution) ucon2pr(WHICHVEL,ucon,&geom,pr); return(0); }
static floperr_t get_offset(floppy_image *floppy, int head, int track, int sector, int sector_is_index, UINT64 *offset) { const struct basicdsk_geometry *geom; UINT64 offs; geom = get_geometry(floppy); /* translate the sector to a raw sector */ if (!sector_is_index) { sector -= geom->first_sector_id; } if (geom->translate_sector) sector = geom->translate_sector(floppy, sector); /* check to see if we are out of range */ if ((head < 0) || (head >= geom->heads) || (track < 0) || (track >= geom->tracks) || (sector < 0) || (sector >= geom->sectors)) return FLOPPY_ERROR_SEEKERROR; if (geom->translate_offset) offs = geom->translate_offset(floppy, geom, track, head, sector); else { offs = 0; offs += track; offs *= geom->heads; offs += head; offs *= geom->sectors; offs += sector; } offs *= geom->sector_length; offs += geom->offset; if (offset) *offset = offs; return FLOPPY_ERROR_SUCCESS; }
void Parser::bake_meshes_recursive(FbxNode * node, FbxAnimLayer * animation_layer) { FbxPose * pose = NULL; FbxTime current_time; FbxAMatrix parent_global_position; FbxAMatrix global_position = get_global_position(node, current_time, pose, &parent_global_position); FbxNodeAttribute* node_attribute = node->GetNodeAttribute(); if(node_attribute) { if(node_attribute->GetAttributeType() == FbxNodeAttribute::eMesh) { FbxMesh * mesh = node->GetMesh(); FbxAMatrix geometry_offset = get_geometry(node); FbxAMatrix global_offset_position = global_position * geometry_offset; FbxVector4* control_points = mesh->GetControlPoints(); bake_global_positions(control_points, mesh->GetControlPointsCount(), global_offset_position); if(mesh && !mesh->GetUserDataPtr()) { VBOMesh * mesh_cache = new VBOMesh; if(mesh_cache->initialize(mesh)) { bake_mesh_deformations(mesh, mesh_cache, current_time, animation_layer, global_offset_position, pose); meshes->push_back(mesh_cache); } } } } const int node_child_count = node->GetChildCount(); for(int node_child_index = 0; node_child_index < node_child_count; ++node_child_index) { bake_meshes_recursive(node->GetChild(node_child_index), animation_layer); } }
void Info::draw(CL_GraphicContext &gc) { CL_String text_to_draw = name; CL_Rect draw_rect = get_geometry(); int draw_xpos = 0; int draw_ypos = 0; //CL_Draw::fill(gc, CL_Rect(draw_xpos, draw_ypos, CL_Size(get_width(), get_height())), CL_Colorf(CL_Colorf::red)); CL_Font font = gui->get_font(); CL_FontMetrics metrics = font.get_font_metrics(gc); draw_ypos += (int) metrics.get_ascent(); CL_Colorf color; int time_diff = CL_System::get_time() - activated_time; float color_value = 1.0f - ( ( (float) time_diff ) / 1000.0f); if ( (color_value <= 1.0f) && (color_value > 0.0f) ) { color = CL_Colorf(color_value, color_value/2.0f, color_value/2.0f, color_value); font.draw_text(gc, draw_xpos, draw_ypos, "#", color); color = CL_Colorf(color_value, color_value/2.0f, color_value/2.0f, 1.0f); text_to_draw = name + comment; set_constant_repaint(true); } else { color = CL_Colorf(0, 0, 0, 1.0f); set_constant_repaint(false); } //font.draw_text(gc, draw_xpos + 16, draw_ypos, text_to_draw, CL_Colorf::white); font.draw_text(gc, draw_xpos + 16-1, draw_ypos-1, text_to_draw, color); }
static floperr_t basicdsk_get_indexed_sector_info(floppy_image *floppy, int head, int track, int sector_index, int *cylinder, int *side, int *sector, UINT32 *sector_length, unsigned long *flags) { const struct basicdsk_geometry *geom = get_geometry(floppy); if (geom->translate_sector) sector_index = geom->translate_sector(floppy, sector_index); sector_index += geom->first_sector_id; if (cylinder) *cylinder = track; if (side) *side = head; if (sector) *sector = sector_index; if (flags) { /* TODO: read DAM or DDAM and determine flags */ *flags = 0; if (geom->get_ddam) *flags = geom->get_ddam(floppy, geom, track, head, sector_index); } return basicdsk_get_sector_length(floppy, head, track, sector_index, sector_length); }
int ipod_open(struct ipod_t* ipod, int silent) { ipod->dh=open(ipod->diskname,O_RDONLY); if (ipod->dh < 0) { if (!silent) perror(ipod->diskname); if(errno == EACCES) return -2; else return -1; } /* Read information about the disk */ if(ioctl(ipod->dh,IPOD_SECTORSIZE_IOCTL,&ipod->sector_size) < 0) { ipod->sector_size=512; if (!silent) { fprintf(stderr,"[ERR] ioctl() call to get sector size failed, defaulting to %d\n" ,ipod->sector_size); } } get_geometry(ipod); return 0; }
// assumes normalized density int user1_init_atmosphere(int *whichvel, int*whichcoord,int i, int j, int k, FTYPE *pr) { int pl,pliter; struct of_geom realgeomdontuse; struct of_geom *ptrrealgeom=&realgeomdontuse; FTYPE pratm[NPR]; get_geometry(i, j, k, CENT, ptrrealgeom); // true coordinate system set_atmosphere(-1,WHICHVEL,ptrrealgeom,pratm); // set velocity in chosen WHICHVEL frame in any coordinate system if(pr[RHO]<pratm[RHO]){ PLOOP(pliter,pl) pr[pl]=pratm[pl]; } *whichvel=WHICHVEL; *whichcoord=PRIMECOORDS; return(0); }