Example #1
0
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));
  }
}
Example #2
0
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;
}
Example #4
0
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);
}
Example #5
0
/* 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);
}
Example #6
0
// 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);
}
Example #7
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);
}
Example #8
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);
	}
}
Example #9
0
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));
}
Example #10
0
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();
}
Example #12
0
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;
}
Example #13
0
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()));
}
Example #14
0
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);
}
Example #15
0
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);
}
Example #16
0
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;
}
Example #17
0
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;
}
Example #18
0
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);

}
Example #19
0
    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;
    }
Example #20
0
// 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);
}
Example #21
0
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;
}
Example #22
0
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;
}
Example #23
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;
	}
}
Example #24
0
// 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);
}
Example #25
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;
}
Example #26
0
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);
  }
}
Example #27
0
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);
}
Example #28
0
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);
}
Example #29
0
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;
}
Example #30
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);


}