void StructureMgrSingleton::ShowAllParts()
{
FeaStructure* fea_struct = GetFeaStruct( m_CurrStructIndex );
Vehicle* veh = VehicleMgr.GetVehicle();
if ( fea_struct && veh )
{
string parent_id = fea_struct->GetParentGeomID();
veh->HideAll();
Geom* parent = veh->FindGeom( parent_id );
if ( parent )
{
parent->SetSetFlag( 1, true ); //add to shown
parent->SetSetFlag( 2, false ); //remove from show
}
vector < FeaPart* > part_vec = fea_struct->GetFeaPartVec();
for ( size_t i = 0; i < part_vec.size(); i++ )
{
part_vec[i]->m_DrawFeaPartFlag.Set( true );
}
vector < SubSurface* > ss_vec = fea_struct->GetFeaSubSurfVec();
for ( size_t i = 0; i < ss_vec.size(); i++ )
{
ss_vec[i]->m_DrawFeaPartFlag.Set( true );
}
}
}
void TreeDlg::OnTreeComputePath()
{
GetDlgItems();
ClearOutputText();
HTREEITEM hSelectedItem = mpTreeCtrl->GetSelectedItem();
if (hSelectedItem == NULL)
AppendOutputText("No item is selected");
else
{
GvPath *selectedItemPath = PathOfItem(hSelectedItem);
if (selectedItemPath == NULL)
AppendOutputText("[PathOfItem(...) returned NULL");
else
{
UtScalarArray<int> *indexArray = selectedItemPath->GetIndexArray();
int count = selectedItemPath->GetIndexCount();
AppendOutputText("Selected ");
Geom *g = selectedItemPath->Resolve();
AppendOutputText(g->GetType()->mpName);
AppendOutputText(" at path");
char buf[20];
for (int i=0; i<count; ++i) {
sprintf(buf, " %d", (*indexArray)[i]);
AppendOutputText(buf);
}
}
}
}
void GvPath::GetCumulativeTransform(Transform3 *T)
{
T->Identity();
int i;
for (i=0; i<mAncestryLength; ++i) {
Geom *g = mAncestry[i];
if (g->IsInstanceOf(TYPE_INFO(GeomWrapped))) {
Transform3 *M = ((GeomWrapped*)g)->GetTransform();
// Explanation of the order of multiplication: Our
// transform libarary treats data points as row vectors;
// transforms act on them by right multiplication, i.e.
// [point] * [matrix] = [new point]. Transforms lower in
// the heirarchy are closer to the data points (the one
// just above the leaf node Geom being the one that acts
// on it first), so the order in which the product of
// transformations act on a point is:
// [point] * [transf n] * ... * [transf 1] * [transf 0]
// = [new point]
// At this point, we've accumulated the product
// [transf i-1] ... [transf 0]
// in T, and we're about to multiply it by [transf i]
// (which is in M), so the order should be M * T.
T->Concat(M, T);
}
}
}
void VSPAEROMgrSingleton::Update()
{
if( m_RefFlag() == MANUAL_REF )
{
m_Sref.Activate();
m_bref.Activate();
m_cref.Activate();
}
else
{
Geom* refgeom = VehicleMgr.GetVehicle()->FindGeom( m_RefGeomID );
if( refgeom )
{
if( refgeom->GetType().m_Type == MS_WING_GEOM_TYPE )
{
WingGeom* refwing = (WingGeom*) refgeom;
m_Sref.Set( refwing->m_TotalArea() );
m_bref.Set( refwing->m_TotalSpan() );
m_cref.Set( refwing->m_TotalChord() );
m_Sref.Deactivate();
m_bref.Deactivate();
m_cref.Deactivate();
}
}
}
}
//==== Get copy of sub surfaces from geom by id and surf number ====//
vector< SubSurface*> SubSurfaceMgrSingleton::GetSubSurfs( string comp_id, int surfnum )
{
vector< SubSurface* > ret_vec;
Geom* geom = GetGeom( comp_id );
if ( !geom )
{
return ret_vec;
}
vector< SubSurface* > all_vec;
all_vec = geom->GetSubSurfVec();
int imain = geom->GetMainSurfID( surfnum );
for ( int i = 0; i < all_vec.size(); i++ )
{
if ( imain == all_vec[i]->m_MainSurfIndx() )
{
ret_vec.push_back( all_vec[i] );
}
}
return ret_vec;
}
//==== Show/NoShow Active Geoms and Children ====//
void ManageGeomScreen::NoShowActiveGeoms( bool flag )
{
//==== Load Active Geom IDs And Children ====//
vector<string> geom_id_vec;
vector<string> active_geom_vec = m_VehiclePtr->GetActiveGeomVec();
for ( int i = 0 ; i < ( int )active_geom_vec.size() ; i++ )
{
Geom* gPtr = m_VehiclePtr->FindGeom( active_geom_vec[i] );
if ( gPtr )
{
gPtr->LoadIDAndChildren( geom_id_vec );
}
}
//==== Set No Show Flag ====//
vector< Geom* > geom_vec = m_VehiclePtr->FindGeomVec( geom_id_vec );
for ( int i = 0 ; i < ( int )geom_vec.size() ; i++ )
{
if ( geom_vec[i] )
{
geom_vec[i]->SetSetFlag( SET_SHOWN , !flag );
geom_vec[i]->SetSetFlag( SET_NOT_SHOWN , flag );
}
}
//jrg FIX!!!
// aircraftPtr->triggerDraw();
LoadBrowser();
}
void ModelBody::RebuildCollisionMesh()
{
if (m_geom) {
if (GetFrame()) RemoveGeomsFromFrame(GetFrame());
DeleteGeoms();
}
m_collMesh = m_model->GetCollisionMesh();
SetPhysRadius(m_collMesh->GetAabb().GetRadius());
//static geom
m_geom = new Geom(m_collMesh->GetGeomTree());
m_geom->SetUserData(static_cast<void*>(this));
m_geom->MoveTo(GetOrient(), GetPosition());
//have to figure out which collision geometries are responsible for which geomtrees
DynGeomFinder dgf;
m_model->GetRoot()->Accept(dgf);
//dynamic geoms
for (auto it = m_collMesh->GetDynGeomTrees().begin(); it != m_collMesh->GetDynGeomTrees().end(); ++it) {
Geom *dynG = new Geom(*it);
dynG->SetUserData(static_cast<void*>(this));
dynG->MoveTo(GetOrient(), GetPosition());
dynG->m_animTransform = matrix4x4d::Identity();
SceneGraph::CollisionGeometry *cg = dgf.GetCgForTree(*it);
if (cg)
cg->SetGeom(dynG);
m_dynGeoms.push_back(dynG);
}
if (GetFrame()) AddGeomsToFrame(GetFrame());
}
void CustomGeomMgrSingleton::SetupCustomDefaultSource( int type, int surf_index,
double l1, double r1, double u1, double w1,
double l2, double r2, double u2, double w2 )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
SourceData sd;
sd.m_Type = type;
sd.m_SurfIndex = surf_index;
sd.m_Len1 = l1;
sd.m_Rad1 = r1;
sd.m_U1 = u1;
sd.m_W1 = w1;
sd.m_Len2 = l2;
sd.m_Rad2 = r2;
sd.m_U2 = u2;
sd.m_W2 = w2;
custom_geom->SetUpDefaultSource( sd );
}
}
double KellyTypeAdapt::eval_boundary_estimator(KellyTypeAdapt::ErrorEstimatorForm* err_est_form, RefMap *rm, SurfPos* surf_pos)
{
// determine the integration order
int inc = (this->sln[err_est_form->i]->get_num_components() == 2) ? 1 : 0;
Func<Ord>** oi = new Func<Ord>* [num];
for (int i = 0; i < num; i++)
oi[i] = init_fn_ord(this->sln[i]->get_edge_fn_order(surf_pos->surf_num) + inc);
// Order of additional external functions.
ExtData<Ord>* fake_ext = dp.init_ext_fns_ord(err_est_form->ext, surf_pos->surf_num);
double fake_wt = 1.0;
Geom<Ord>* fake_e = init_geom_ord();
Ord o = err_est_form->ord(1, &fake_wt, oi, oi[err_est_form->i], fake_e, fake_ext);
int order = rm->get_inv_ref_order();
order += o.get_order();
limit_order(order);
// Clean up.
for (int i = 0; i < this->num; i++)
if (oi[i] != NULL) { oi[i]->free_ord(); delete oi[i]; }
delete [] oi;
delete fake_e;
delete fake_ext;
// eval the form
Quad2D* quad = this->sln[err_est_form->i]->get_quad_2d();
int eo = quad->get_edge_points(surf_pos->surf_num, order);
double3* pt = quad->get_points(eo);
int np = quad->get_num_points(eo);
// init geometry and jacobian*weights
Geom<double>* e = init_geom_surf(rm, surf_pos, eo);
double3* tan = rm->get_tangent(surf_pos->surf_num, eo);
double* jwt = new double[np];
for(int i = 0; i < np; i++)
jwt[i] = pt[i][2] * tan[i][2];
// function values
Func<scalar>** ui = new Func<scalar>* [num];
for (int i = 0; i < num; i++)
ui[i] = init_fn(this->sln[i], eo);
ExtData<scalar>* ext = dp.init_ext_fns(err_est_form->ext, rm, eo);
scalar res = boundary_scaling_const *
err_est_form->value(np, jwt, ui, ui[err_est_form->i], e, ext);
for (int i = 0; i < this->num; i++)
if (ui[i] != NULL) { ui[i]->free_fn(); delete ui[i]; }
delete [] ui;
if (ext != NULL) { ext->free(); delete ext; }
e->free(); delete e;
delete [] jwt;
return std::abs(0.5*res); // Edges are parameterized from 0 to 1 while integration weights
// are defined in (-1, 1). Thus multiplying with 0.5 to correct
// the weights.
}
double KellyTypeAdapt::eval_volumetric_estimator(KellyTypeAdapt::ErrorEstimatorForm* err_est_form, RefMap *rm)
{
// determine the integration order
int inc = (this->sln[err_est_form->i]->get_num_components() == 2) ? 1 : 0;
Func<Ord>** oi = new Func<Ord>* [num];
for (int i = 0; i < num; i++)
oi[i] = init_fn_ord(this->sln[i]->get_fn_order() + inc);
// Order of additional external functions.
ExtData<Ord>* fake_ext = dp.init_ext_fns_ord(err_est_form->ext);
double fake_wt = 1.0;
Geom<Ord>* fake_e = init_geom_ord();
Ord o = err_est_form->ord(1, &fake_wt, oi, oi[err_est_form->i], fake_e, fake_ext);
int order = rm->get_inv_ref_order();
order += o.get_order();
limit_order(order);
// Clean up.
for (int i = 0; i < this->num; i++)
if (oi[i] != NULL) { oi[i]->free_ord(); delete oi[i]; }
delete [] oi;
delete fake_e;
delete fake_ext;
// eval the form
Quad2D* quad = this->sln[err_est_form->i]->get_quad_2d();
double3* pt = quad->get_points(order);
int np = quad->get_num_points(order);
// init geometry and jacobian*weights
Geom<double>* e = init_geom_vol(rm, order);
double* jac = rm->get_jacobian(order);
double* jwt = new double[np];
for(int i = 0; i < np; i++)
jwt[i] = pt[i][2] * jac[i];
// function values
Func<scalar>** ui = new Func<scalar>* [num];
for (int i = 0; i < num; i++)
ui[i] = init_fn(this->sln[i], order);
ExtData<scalar>* ext = dp.init_ext_fns(err_est_form->ext, rm, order);
scalar res = volumetric_scaling_const *
err_est_form->value(np, jwt, ui, ui[err_est_form->i], e, ext);
for (int i = 0; i < this->num; i++)
if (ui[i] != NULL) { ui[i]->free_fn(); delete ui[i]; }
delete [] ui;
if (ext != NULL) { ext->free(); delete ext; }
e->free(); delete e;
delete [] jwt;
return std::abs(res);
}
void FourWheeler::create(World* in_world, Pose3D in_pose3D)
{
// TODO use full position data
Pose in_pose(in_pose3D.point().x(), in_pose3D.point().y(), Deg(0));
msg::Subs<num::Pose> pose(m_pChannel,"true-pose");
msg::Subs<num::Speed, FourWheeler> reqSpeed(m_pChannel,"speed-requested", this, &FourWheeler::reqSpeed);
msg::Subs<num::Speed> currentSpeed(m_pChannel, "speed-current");
pose.value = in_pose;
m_pSpace = new SimpleSpace(in_world->getSpace());
m_pChassis = new Body(in_world);
m_pChassis->setPosition(in_pose.x().m(),in_pose.y().m(),STARTZ().m());
m_pChassisBox = new BoxGeom(m_pChassis, m_pSpace, ROBOT_LENGTH().m(),ROBOT_WIDTH().m(),ROBOT_HEIGHT().m());
m_pChassisBox->setMass(CHASSIS_MASS());
m_wheels = new Body[4];
for (int i = 0; i < 4; i++)
{
m_wheels[i].create(in_world);
dQuaternion q;
dQFromAxisAndAngle (q,1,0,0,M_PI*0.5);
m_wheels[i].setQuaternion(q);
Geom* geom = new SphereGeom(&m_wheels[i], m_pSpace, RADIUS().m());
geom->setMass(WMASS());
// Magic number (see Pisvejc): make it too big, and turning won't be possible, make it too small, and
// robot will just stay on place, regardless of how fast wheels are turning
geom->m_contactData.mu = 0.75;
}
m_wheels[0].setPosition(in_pose.x().m()+0.4*ROBOT_LENGTH().m(),
in_pose.y().m()+0.5*ROBOT_WIDTH().m(),STARTZ().m()-0.5*ROBOT_HEIGHT().m());
m_wheels[1].setPosition(in_pose.x().m()+0.4*ROBOT_LENGTH().m(),
in_pose.y().m()-0.5*ROBOT_WIDTH().m(),STARTZ().m()-0.5*ROBOT_HEIGHT().m());
m_wheels[2].setPosition(in_pose.x().m()-0.4*ROBOT_LENGTH().m(),
in_pose.y().m()+0.5*ROBOT_WIDTH().m(),STARTZ().m()-0.5*ROBOT_HEIGHT().m());
m_wheels[3].setPosition(in_pose.x().m()-0.4*ROBOT_LENGTH().m(),
in_pose.y().m()-0.5*ROBOT_WIDTH().m(),STARTZ().m()-0.5*ROBOT_HEIGHT().m());
for (int i=0; i<4;i++)
{
m_joints[i] = new Hinge2Joint(in_world);
m_joints[i]->attach(m_pChassis,&m_wheels[i]);
double a[3];
m_wheels[i].getPosition(a);
m_joints[i]->setAnchor (a[0],a[1],a[2]);
m_joints[i]->setAxis1(0,0,(i<2 ? 1 : -1));
m_joints[i]->setAxis2(0,1,0);
m_joints[i]->setParam(dParamSuspensionERP,0.8);
m_joints[i]->setParam(dParamSuspensionCFM,1e-5);
m_joints[i]->setParam(dParamVel2,0);
m_joints[i]->setParam(dParamFMax2,FMAX());
m_joints[i]->setParam(dParamLoStop,0);
m_joints[i]->setParam(dParamHiStop,0);
}
}
scalar HcurlOrthoHP::eval_error(biform_val_t bi_fn, biform_ord_t bi_ord,
MeshFunction *sln1, MeshFunction *sln2, MeshFunction *rsln1, MeshFunction *rsln2,
RefMap *rv1, RefMap *rv2, RefMap *rrv1, RefMap *rrv2)
{
// determine the integration order
int inc = (rsln1->get_num_components() == 2) ? 1 : 0;
Func<Ord>* ou = init_fn_ord(rsln1->get_fn_order() + inc);
Func<Ord>* ov = init_fn_ord(rsln2->get_fn_order() + inc);
double fake_wt = 1.0;
Geom<Ord>* fake_e = init_geom_ord();
Ord o = bi_ord(1, &fake_wt, ou, ov, fake_e, NULL);
int order = rrv1->get_inv_ref_order();
order += o.get_order();
limit_order(order);
ou->free_ord(); delete ou;
ov->free_ord(); delete ov;
delete fake_e;
// eval the form
Quad2D* quad = sln1->get_quad_2d();
double3* pt = quad->get_points(order);
int np = quad->get_num_points(order);
// init geometry and jacobian*weights
Geom<double>* e = init_geom_vol(rrv1, order);
double* jac = rrv1->get_jacobian(order);
double* jwt = new double[np];
for(int i = 0; i < np; i++)
jwt[i] = pt[i][2] * jac[i];
// function values and values of external functions
Func<scalar>* err1 = init_fn(sln1, rv1, order);
Func<scalar>* err2 = init_fn(sln2, rv2, order);
Func<scalar>* v1 = init_fn(rsln1, rrv1, order);
Func<scalar>* v2 = init_fn(rsln2, rrv2, order);
for (int i = 0; i < np; i++)
{
err1->val0[i] = err1->val0[i] - v1->val0[i];
err1->val1[i] = err1->val1[i] - v1->val1[i];
err1->curl[i] = err1->curl[i] - v1->curl[i];
err2->val0[i] = err2->val0[i] - v2->val0[i];
err2->val1[i] = err2->val1[i] - v2->val1[i];
err2->curl[i] = err2->curl[i] - v2->curl[i];
}
scalar res = bi_fn(np, jwt, err1, err2, e, NULL);
e->free(); delete e;
delete [] jwt;
err1->free_fn(); delete err1;
err2->free_fn(); delete err2;
v1->free_fn(); delete v1;
v2->free_fn(); delete v2;
return res;
}
Transform3 *GvPath::GetLocalTransform()
{
if (mAncestryLength <= 1) { return &Transform3::IDENTITY; }
Geom *parent = mAncestry[mAncestryLength-2];
if (!parent->IsInstanceOf(TYPE_INFO(GeomWrapped))) {
return NULL;
}
return ((GeomWrapped*)parent)->GetTransform();
}
//==== Item in Geom Browser Was Selected ====//
void ManageGeomScreen::GeomBrowserCallback()
{
//==== Find Vector of All Selections ====//
vector< string > selVec = GetSelectedBrowserItems();
//==== Find Last Selected Geom ====//
int last = m_GeomUI->geomBrowser->value();
if ( ( last >= 2 ) && Fl::event_state( FL_ALT ) ) // Select Children
{
Geom* lastSelGeom = m_VehiclePtr->FindGeom( m_DisplayedGeomVec[last - 2] );
if ( lastSelGeom )
{
vector<string> cVec;
lastSelGeom->LoadIDAndChildren( cVec );
for ( int i = 1 ; i < ( int )cVec.size(); i++ )
{
SelectGeomBrowser( cVec[i] );
selVec.push_back( cVec[i] );
}
}
}
//==== Check if Geom Already Selected ====//
m_CollapseFlag = false;
if ( m_LastSelectedGeomID != "NONE" && selVec.size() == 1 )
{
string lastSel = selVec[0];
if ( lastSel == m_LastSelectedGeomID )
{
m_CollapseFlag = true;
Geom* lastSelGeom = m_VehiclePtr->FindGeom( m_LastSelectedGeomID );
if ( lastSelGeom )
{
lastSelGeom->m_GuiDraw.ToggleDisplayChildrenFlag();
if ( lastSelGeom->GetChildIDVec().size() == 0 ) // No Children Dont Collapse
{
lastSelGeom->m_GuiDraw.SetDisplayChildrenFlag( true );
}
}
}
}
m_LastSelectedGeomID = "NONE";
if ( selVec.size() == 1 )
{
m_LastSelectedGeomID = selVec[0];
}
m_VehiclePtr->SetActiveGeomVec( selVec );
LoadActiveGeomOutput();
// m_ScreenMgr->UpdateAllScreens();
ShowHideGeomScreens();
//jrg FIX!!!
// aircraftPtr->triggerDraw();
}
//===== Check And Clear Trigger Event ====//
bool CustomGeomMgrSingleton::CheckClearTriggerEvent( int gui_id )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
return custom_geom->CheckClearTriggerEvent( gui_id );
}
return false;
}
//==== Remove XSec Surface To Current Geom ====//
void CustomGeomMgrSingleton::RemoveXSecSurf( const string& id )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->RemoveXSecSurf( id );
}
}
//==== Skin XSec Surf =====//
void CustomGeomMgrSingleton::SkinXSecSurf( bool closed_flag )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->SkinXSecSurf(closed_flag );
}
}
void CustomGeomMgrSingleton::SetCustomCenter( double x, double y, double z )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->SetCenter( x, y, z );
}
}
//==== Clone Surf And Apply Transform =====//
void CustomGeomMgrSingleton::TransformSurf( int index, Matrix4d & mat )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->TransformSurf( index, mat );
}
}
//==== Set VSP Surf Type For Current Custom Geom =====//
void CustomGeomMgrSingleton::SetVspSurfCfdType( int type, int surf_id )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->SetVspSurfCfdType( type, surf_id );
}
}
void CustomGeomMgrSingleton::ClearAllCustomDefaultSources()
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->ClearAllDefaultSources();
}
}
string CustomGeomMgrSingleton::GetCustomParm( int index )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
return custom_geom->FindParmID( index );
}
return string();
}
//==== Get copy of sub surfaces from geom by id ====//
vector< SubSurface*> SubSurfaceMgrSingleton::GetSubSurfs( string comp_id )
{
vector< SubSurface* > ret_vec;
Geom* geom = GetGeom( comp_id );
if ( !geom )
{
return ret_vec;
}
return geom->GetSubSurfVec();
}
//==== Build Update Gui Instruction Vector ====//
vector< GuiUpdate > CustomGeomMgrSingleton::GetGuiUpdateVec()
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
return custom_geom->GetGuiUpdateVec();
}
vector< GuiUpdate > defvec;
return defvec;
}
bool GeomScreen::isParentSelected( Geom* geomPtr, vector< Geom* > & selVec )
{
Geom* checkGeom = geomPtr;
while ( checkGeom )
{
for ( int i = 0 ; i < (int)selVec.size() ; i++ )
if ( checkGeom == selVec[i] )
return true;
checkGeom = checkGeom->getParent();
}
return false;
}
//==== Is Parent (or Higher) Selected ====//
bool ManageGeomScreen::IsParentSelected( string geom_id, vector< string > & selVec )
{
Geom* checkGeom = m_VehiclePtr->FindGeom( geom_id );
while ( checkGeom )
{
if ( vector_contains_val( selVec, checkGeom->GetID() ) )
{
return true;
}
string parent_id = checkGeom->GetParentID();
checkGeom = m_VehiclePtr->FindGeom( parent_id );
}
return false;
}
//==== Update Gui ====//
void CustomGeomMgrSingleton::AddUpdateGui( int gui_id, const string & parm_id )
{
Geom* gptr = VehicleMgr.GetVehicle()->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
GuiUpdate gu;
gu.m_GuiID = gui_id;
gu.m_ParmID = parm_id;
custom_geom->AddUpdateGui( gu );
}
}
//==== Add Parm To Current Custom Geom ====//
string CustomGeomMgrSingleton::AddParm( int type, const string & name, const string & group )
{
Vehicle* veh = VehicleMgr.GetVehicle();
Geom* gptr = veh->FindGeom( m_CurrGeom );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
return custom_geom->AddParm( type, name, group );
}
return string();
}
//==== Init Custom Geom ====//
void CustomGeomMgrSingleton::InitGeom( const string& id, const string& module_name )
{
Vehicle* veh = VehicleMgr.GetVehicle();
Geom* gptr = veh->FindGeom( id );
//==== Check If Geom is Valid and Correct Type ====//
if ( gptr && gptr->GetType().m_Type == CUSTOM_GEOM_TYPE )
{
m_CurrGeom = id;
CustomGeom* custom_geom = dynamic_cast<CustomGeom*>( gptr );
custom_geom->SetScriptModuleName( module_name );
custom_geom->InitGeom();
m_ModuleGeomIDMap[ module_name ] = id;
}
}
static GeomPtr
normalize(const Geom& g)
{
GeomPtr g2(g.clone());
g2->normalize();
return g2;
}
